Skip to content
Back to search

rayfernando-skills

MarketplaceWorks with Claude CodeGitHub

Ray Fernando's collection of Skill files for AI coding agents. First up: running-bug-review-board, a real-user QA workflow with a Bug Review Board (BRB) feedback loop.

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/rayfernando1337--rayfernando-skills/badge.svg)](/listings/rayfernando1337--rayfernando-skills)

HTML

<a href="/listings/rayfernando1337--rayfernando-skills"><img src="/api/listings/rayfernando1337--rayfernando-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

**Cursor:**

npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/waves/skills/waves -a cursor

**Codex:**

codex plugin marketplace add RayFernando1337/rayfernando-skills
codex plugin add waves-codex@rayfernando-skills

**Claude Code:** `/plugin install waves@rayfernando-skills` (Cursor-tuned) or `/plugin install waves-codex@rayfernando-skills` (Codex-tuned).

**Cross-vendor (`npx skills add`):** point the installer at either skill folder and pass `-a <agent>` (e.g. `-a codex`, `-a claude-code`, `--all`).

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.

.claude-plugin/marketplace.json · Manifest · 1 lines

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

  1. {"name":"rayfernando-skills","owner":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"metadata":{"description":"Ray Fernando's collection of installable Skill files for AI coding agents.","version":"0.12.0"},"plugins":[{"name":"running-bug-review-board","source":"./plugins/running-bug-review-board","description":"Real-user QA and Bug Review Board workflow for web and iOS/iPadOS app repos. Files P0/P1/P2 bug reports, produces YES/NO phase sign-off, generates an editorial HTML QA dashboard, syncs with confirmed issue trackers, and supports a separate Interactive BRB triage flow.","version":"0.5.0","category":"qa","tags":["qa","manual-testing","bug-review-board","real-user-testing","browser-automation","html-report","magazine-design","dieter-rams","linear","github-issues","ios-simulator","bi-directional-sync","triage-heuristics","computer-use","chrome-devtools","waves","parallel-qa"],"author":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"homepage":"https://github.com/RayFernando1337/rayfernando-skills","license":"Apache-2.0"},{"name":"waves","source":"./plugins/waves","description":"WAVES (Workers, Aggregate, Verify, Extend): wave-based orchestration for Cursor. Decompose a big task into independent slices, fan them out to isolated parallel subagents with the Task tool as a bounded wave, verify each handoff, then synthesize. The manifest is the stop function: continue until every slice is terminal; stop only on completion, stagnation, or budget. Reduce entropy first; route scouting to cheap fast models. Runs in place of cloud orchestration. Opt-in via /waves. For large research, analysis, audits, and codebase or data exploration. Formerly parallel-orchestrate.","version":"0.6.0","category":"orchestration","tags":["waves","wave-engineering","orchestration","parallel","subagents","multitask","fan-out","cursor","task-tool","research","audit","verification","handoffs","entropy-reduction","decomposition","model-routing","composer","parallel-orchestrate","evals"],"author":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"homepage":"https://github.com/RayFernando1337/rayfernando-skills","license":"Apache-2.0","skills":["./skills/waves"]},{"name":"waves-codex","source":"./plugins/waves-codex","description":"WAVES (Workers, Aggregate, Verify, Extend): wave-based orchestration for Codex. Decompose into independent slices, spawn parallel Codex subagents (or spawn_agents_on_csv) as a bounded wave, verify evidence-backed handoffs, then synthesize. The manifest is the stop function: stop only on completion, stagnation, or budget. Reduce entropy first; route scouting reads to gpt-5.6-terra low. Tuned for Codex roles, config.toml limits, codex exec fleets, and a Desktop coordinator-thread mode. Formerly parallel-orchestrate-codex.","version":"0.6.0","category":"orchestration","tags":["waves","wave-engineering","orchestration","parallel","subagents","fan-out","codex","spawn-agents-on-csv","config-toml","research","audit","verification","handoffs","entropy-reduction","decomposition","model-routing","reasoning-effort","parallel-orchestrate-codex","evals"],"author":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"homepage":"https://github.com/RayFernando1337/rayfernando-skills","license":"Apache-2.0","skills":["./skills/waves-codex"]},{"name":"bootstrap-ios","source":"./plugins/bootstrap-ios","description":"Meta-skill for iOS and macOS app agents: load the right Swift, SwiftUI, testing, data, build, simulator, and XcodeBuildMCP guidance before touching an Apple-platform repo.","version":"0.2.0","category":"ios","tags":["ios","macos","swift","swiftui","xcode","xcodebuild","xcodebuildmcp","mcp","simulator","agent-skills","bootstrap"],"author":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"homepage":"https://github.com/RayFernando1337/rayfernando-skills","license":"Apache-2.0","skills":["./skills/bootstrap-ios"]},{"name":"swiftui-animation-match","source":"./plugins/swiftui-animation-match","description":"Match UI/UX interaction needs to proven SwiftUI animation patterns from curated open-source catalogs, with system-first restraint. Ships an analyzed catalog of Shubham0812/SwiftUI-Animations (30 animations + 7 Metal shaders) grouped by interaction moment, a matching playbook, and a repeatable recipe for cataloging more animation repos.","version":"0.1.0","category":"ios","tags":["swiftui","animation","ios","ux","interaction-design","motion","juice","metal-shaders","haptics","liquid-glass","pattern-matching","loaders","card-decks","reveals"],"author":{"name":"Ray Fernando","url":"https://github.com/RayFernando1337"},"homepage":"https://github.com/RayFernando1337/rayfernando-skills","license":"Apache-2.0","skills":["./skills/swiftui-animation-match"]}]}
README.md · README · 534 lines

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

  1. # rayfernando-skills
  2. A collection of installable **Skill files** for AI coding agents, built to play together instead of sitting in a grab bag. The centerpiece is **`waves`**, wave engineering for agent teams (**WAVE = Workers · Aggregate · Verify · Extend**): one big task fans out to a bounded, *verified* team of parallel subagents instead of grinding through an open-ended loop. Around it: `running-bug-review-board`, the real-user QA skill the collection started with (its parallel QA pass now runs as a wave), and `bootstrap-ios`, a single entry point for loading Ray's iOS/macOS agent skill stack.
  3. [![Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
  4. ## Skills in this collection
  5. | Skill | What it does | Primary install (Claude Code) |
  6. |---|---|---|
  7. | **[waves](#waves-wave-engineering-for-agent-teams)** · Cursor + Codex | Turn one big task into a team of parallel subagents: a bounded, verified **wave** (Workers · Aggregate · Verify · Extend) instead of an open-ended loop. For big research, audits, data analysis, and codebase exploration. | `/plugin install waves@rayfernando-skills` |
  8. | **[running-bug-review-board](#running-bug-review-board-real-user-qa)** · QA | Point an AI agent at your *live* app; it QAs like a real user, files P0/P1/P2 bug reports, and returns a **YES/NO** ship verdict plus a shareable HTML report. Runs its parallel pass as a wave when `waves` is installed. | `/plugin install running-bug-review-board@rayfernando-skills` |
  9. | **[bootstrap-ios](#bootstrap-ios-load-the-ios-agent-stack)** · iOS/macOS | One entry point for Swift, SwiftUI, SwiftData/Core Data, Swift Testing, Xcode build/test/simulator, XcodeBuildMCP, and curated community iOS skills. | `/plugin install bootstrap-ios@rayfernando-skills` |
  10. | **[swiftui-animation-match](#swiftui-animation-match-interaction-to-animation-matching)** · iOS UX | Match a UI/UX interaction need ("saving should feel satisfying") to a proven SwiftUI animation pattern from curated open-source catalogs — or to the system affordance that makes custom motion unnecessary. Extensible: each new animation repo becomes one more catalog. | `/plugin install swiftui-animation-match@rayfernando-skills` |
  11. Each skill installs into Claude Code, Cursor, Codex, and ~50 other agents; full per-agent steps are in the sections below.
  12. **Jump to:** [waves](#waves-wave-engineering-for-agent-teams) · [running-bug-review-board (QA)](#running-bug-review-board-real-user-qa) · [bootstrap-ios](#bootstrap-ios-load-the-ios-agent-stack) · [swiftui-animation-match](#swiftui-animation-match-interaction-to-animation-matching) · [Repo structure](#repo-structure) · [Contributing](#contributing)
  13. ## How the skills play together
  14. This collection is becoming an ecosystem rather than a list. The skills reference and strengthen each other:
  15. - **`waves` is the orchestration layer.** Any job too big for one clean linear pass (research, audits, data analysis, a QA sweep) can run as a bounded wave of parallel, verified workers.
  16. - **`running-bug-review-board` is its first consumer.** When `waves` is installed, the QA skill's parallel mode runs as a wave: coverage-gated shards, structured handoffs, tiered verification of PASS/FAIL claims, and cheap-model routing for low-risk shards.
  17. - **One discipline, two agent platforms.** The same wave playbook ships tuned for Cursor (`waves`) and Codex (`waves-codex`), with every Cursor→Codex translation recorded in [`adaptation-notes.md`](plugins/waves-codex/skills/waves-codex/references/adaptation-notes.md) so the variants can't drift apart silently.
  18. - **`bootstrap-ios` is the router.** Rather than pasting every community Swift rule into context, it loads the right focused skill for the task, the same progressive-disclosure principle the other skills are built on. When the task is animation or motion work, it routes to `swiftui-animation-match`.
  19. - **`swiftui-animation-match` is the first catalog skill.** Its catalogs were themselves built with a wave: parallel read-only workers each read a slice of the source repo and returned structured entries. The recipe for cataloging the next animation repo (documented in the skill) reuses that same fan-out.
  20. ---
  21. ## waves: wave engineering for agent teams
  22. > **`waves`** turns one big task into a team of agents. The lead agent splits the goal into independent slices, fans them out to isolated parallel **W**orkers, **A**ggregates their structured handoffs, **V**erifies the evidence behind each one (the moat), and **E**xtends into another wave only when the verified results earn it. A wave is a bounded round with verification as the stop condition, not an open-ended loop.
  23. Reach for it when a single linear pass would be slow and the work splits into independent slices: big research jobs, whole-repo audits, large data analysis, multi-stream comparisons, codebase exploration. It ships as two tool-tuned variants with the same discipline and different mechanics:
  24. - **[`waves`](plugins/waves/skills/waves/SKILL.md)** is for **Cursor**, built on parallel `Task` tool calls: isolated background subagents, custom `.cursor/agents/` roles (with a fallback when a role isn't registered), per-slice model routing, and worktree-isolated competing attempts. It adopts the principles the Cursor team proved out in their cloud `orchestrate` plugin (planners plan, workers hand off up, no cross-talk) and runs **in place of** cloud orchestration — local subagent runs cover the whole workload with zero setup.
  25. - **[`waves-codex`](plugins/waves-codex/skills/waves-codex/SKILL.md)** is for **Codex**, built on Codex subagents: built-in and custom TOML roles, `spawn_agents_on_csv` for row-shaped fleets, `config.toml` thread/depth limits, reasoning-effort routing, and `codex exec` fleets for scripted runs.
  26. ### Why a wave and not a loop
  27. The default way to push an agent through a big job is a loop: one context, one agent, iterate until it looks done. Loops fail quietly, in two ways. First, a loop doesn't know when to stop; its stop condition is "seems done," or a spent budget. Second, iteration is non-monotonic: past a point, more rounds make the output *worse*, not just more expensive, because one long context accumulates every dead end, and models told to "double-check yourself" with no external signal flip correct answers to wrong more often than the reverse (sources for these claims are cited in [`verification.md`](plugins/waves/skills/waves/references/verification.md)).
  28. A wave restructures the work so neither failure can happen silently:
  29. | | An open-ended loop | A wave |
  30. |---|---|---|
  31. | Stop condition | "Looks done," or the budget runs out | A verification barrier: evidence checked, then a deliberate extend-or-stop decision |
  32. | Context | One thread carries every dead end forward | Isolated workers; only distilled, verified handoffs move between waves |
  33. | More effort buys | More rounds over the same context; quality can drop as cost rises | More *independent* attempts in parallel, then selection, budgeted ~60% generation / 40% verification |
  34. | Coverage | Whatever the loop happened to touch | A manifest written before spawning: N slices out = N handoffs checked back in |
  35. | Bounds | Emergent | Explicit: 3–8 workers per wave, a stated worker/token budget, and a manifest-gated stop (completion, stagnation, or budget — never "we did two waves") |
  36. Loops aren't banned. They're right exactly when a cheap, reliable, near-ground-truth verifier exists and gives a crisp signal: a failing test, an exec error, a schema check. That's code-with-tests territory, and the skill says to keep loop-until-done there (still hard-capped). Everything open-ended (research, analysis, audits, writing, exploration) is where waves win: at equal cost, independent attempts plus verification usually beat critique/debate loops, and the verify round is what turns parallel exploration into one answer you can trust.
  37. ### What a run actually looks like
  38. 1. **Discover before decomposing.** A few cheap tool calls to learn the shape of the problem. If the goal is vague, treat it as *entropy reduction* first: dig locally, send a small scouting wave at the unknowns, ask the user only when a question genuinely pays. Slicing a vague goal yields overlapping, mis-sized slices.
  39. 2. **Stage the data and prove coverage.** Remote or messy inputs get pulled, cleaned, and pre-chunked once, centrally, then checked (counts, bounds, partition sums) *before* anything spawns. A missing chunk is a silent blind spot.
  40. 3. **Triage into a wave manifest.** State the run shape out loud in one line, then give every slice a row (scope, worker type, model, `depends_on`, verification tier) written *before* spawning. The manifest doubles as the completion gate: a worker that never returns can no longer silently drop its slice.
  41. 4. **Fan out in parallel.** Wave 1 is every slice with no dependencies, launched at once as isolated workers; a dependent slice launches only after its dependency's handoff is verified. Each prompt is fully self-contained (workers can't see the chat) and ends with a required structured handoff format.
  42. 5. **Verify before trusting.** A worker's `Status: success` is a claim, not evidence. Every handoff gets cheap checks (citations resolve, scope matches, headline counts recount), and contested or high-stakes claims go to dedicated *blinded* verifiers that see the claim and its sources but never the generator's reasoning or authorship.
  43. 6. **Extend deliberately, or stop.** Open questions become candidate second-wave tasks; each barrier compresses the verified findings to disk so the next wave reads distilled synthesis, never raw transcripts. When a wave surfaces nothing new, the run is over.
  44. 7. **Deliver one artifact**, with each claim's confidence carried through (`verified` / `single-sourced` / `unverified`). A low-confidence finding never gets laundered into a confident sentence.
  45. The run that shaped the skill: one "analyze all my messages and build a roadmap" request became **16 workers across 3 waves**, and the staging gate caught a timestamp-sort bug *before* fan-out, when it could still be fixed once centrally instead of corrupting the partition every data worker depended on. The full worked example and reusable recipes (repo audit, row-shaped codemod, CI-failure triage, implement-a-reviewed-plan) are in [`examples.md`](plugins/waves/skills/waves/references/examples.md).
  46. ### The discipline that makes it converge
  47. - **Verification is the stop function.** The single load-bearing idea: a wave ends at a barrier where evidence is checked before anything extends the run. Everything else exists to make that check cheap and honest.
  48. - **Entropy-first decomposition.** Reduce uncertainty (dig locally → scouting wave → ask last) before slicing, aiming each probe at the unknown that eliminates the most plans. Grounded in the information-gain literature, with the mechanisms (not just the citations) written into the skill.
  49. - **Tiered, blinded verification.** Spend the checking budget by stakes: auto-accept → single verifier → multi-model panel → debate. Verifiers reason against the cited sources with authorship hidden, because LLM judges favor output labeled as their own.
  50. - **Per-slice model routing.** Scouting and read-heavy slices run on cheap fast models (Composer on Cursor, low reasoning effort on Codex); frontier models are reserved for verification, synthesis, and high-stakes calls. Model slugs are read from the environment, never guessed.
  51. - **Multi-model panels for the highest stakes.** Fan the same contested slice to several different models and synthesize one verdict. Most of the gain is in the synthesis step, not the model diversity (OpenRouter's Fusion result), and judge panels drawn from disjoint model families beat a single frontier judge (PoLL).
  52. - **Context hygiene between waves.** One scratch dir per run (`.waves/<run>/`), handoff digests capped, synthesis compressed at every barrier. Long, irrelevant context measurably degrades reasoning, so it never travels.
  53. - **Measured, not vibed.** Both variants ship `evals/`: with-skill vs baseline A/B runs in fresh sessions, graded PASS/FAIL against fixtures with seeded ground truth, including a deliberately wrong count and a phantom citation the orchestrator must catch before synthesis.
  54. - **Re-verified mechanics.** The Cursor/Codex plumbing carries a "checked on" date and gets re-verified against live docs and bug trackers. When good ideas show up elsewhere (a public deep-research skill, the Cursor team's `orchestrate` plugin), they're verified first, then folded in.
  55. ### How it enriches the other skills
  56. Waves is the orchestration layer of this collection, and the QA skill is its first consumer. With `waves` installed, `running-bug-review-board` runs its parallel pass as a bounded wave: a Test-ID coverage gate before launch (every scenario in exactly one shard, counts sum to the plan), structured shard handoffs instead of transcript-tailing, tiered verification of PASS/FAIL claims (the coordinator personally re-runs write-path and highest-risk IDs), and cheap-model routing for low-risk shards ([details](plugins/running-bug-review-board/skills/running-bug-review-board/references/parallel-coordinator.md)). Same pattern, different domain: QA shards are just slices, and run reports are just handoffs.
  57. ### Example prompts
  58. Because a run spawns more agents than usual, it's **opt-in**: invoke it explicitly with `/waves` (or `/waves-codex`) rather than relying on auto-trigger (`disable-model-invocation: true`).
  59. ```text
  60. /waves analyze all 3,000 tickets in support-tickets.csv and rank the top themes with counts
  61. /waves research OpenAI Realtime, LiveKit, and Pipecat for a voice agent, then give me a comparison and recommendation
  62. /waves audit this repo across security, performance, dead code, and test coverage in one severity-ordered report
  63. /waves read my whole chat export, find the recurring goals and frustrations, and turn them into an app roadmap
  64. /waves implement the reviewed plan in docs/plan.md: research wave, then disjoint edit workers, then a verify wave
  65. ```
  66. ### Install waves
  67. **Cursor:**
  68. ```bash
  69. npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/waves/skills/waves -a cursor
  70. ```
  71. **Codex:**
  72. ```bash
  73. codex plugin marketplace add RayFernando1337/rayfernando-skills
  74. codex plugin add waves-codex@rayfernando-skills
  75. ```
  76. **Claude Code:** `/plugin install waves@rayfernando-skills` (Cursor-tuned) or `/plugin install waves-codex@rayfernando-skills` (Codex-tuned).
  77. **Cross-vendor (`npx skills add`):** point the installer at either skill folder and pass `-a <agent>` (e.g. `-a codex`, `-a claude-code`, `--all`).
  78. ### What's inside
  79. - [`SKILL.md`](plugins/waves/skills/waves/SKILL.md) (per variant): the orchestration playbook, covering the loop, bounded-wave caps, the worker prompt contract, verification tiers, and model routing.
  80. - `references/`: [`handoff-format.md`](plugins/waves/skills/waves/references/handoff-format.md) (the structured worker handoff contract), [`verification.md`](plugins/waves/skills/waves/references/verification.md) (the verification playbook, with sources), and [`examples.md`](plugins/waves/skills/waves/references/examples.md) (the worked run + decomposition recipes). The Codex variant adds [`recommended-config.md`](plugins/waves-codex/skills/waves-codex/references/recommended-config.md) and [`adaptation-notes.md`](plugins/waves-codex/skills/waves-codex/references/adaptation-notes.md), the Cursor→Codex translation record.
  81. - `evals/`: scenarios, fixtures with known ground truth, and the A/B grading protocol ([`evals/README.md`](plugins/waves/skills/waves/evals/README.md)).
  82. ---
  83. ## running-bug-review-board: real-user QA
  84. > **`running-bug-review-board`** points an AI agent at your *live* app to QA it like a real, slightly unforgiving customer: it drives the UI, files structured P0/P1/P2 bug reports with reproduction steps, and gives you a **YES/NO** "is this ready to ship?" verdict, plus a self-contained HTML report you can hand to the team.
  85. ### What you get
  86. Most AI workflows point at *code review* and miss where users actually hit bugs: the live app, on a real phone, with stale storage from yesterday and a flaky auth provider the unit tests never see. This Skill file encodes a battle-tested QA cadence so an agent can find those bugs for you.
  87. - **A real-user QA pass, not a code review.** The agent drives the app from URLs and clicks; it is *forbidden* from marking anything "pass" by reading source. It hunts the failures users hit first: stale state across flows, mobile overflow, auth↔routing races, copy that lies, paths that 404 mid-onboarding.
  88. - **Structured bug reports.** Every defect lands as `BUG-NNN-*.md` with severity (P0/P1/P2), impact, what-happened-vs-expected, reproduction steps, and evidence (screenshots, console, network).
  89. - **A ship/defer decision.** Each pass ends with a **YES/NO** sign-off for the phase, listing open P0/P1 blockers and a paste-ready handoff prompt for the next agent.
  90. - **An editorial HTML dashboard** stakeholders can open and share: the bug list and each bug report, regenerated every pass. ([see it below](#see-the-output))
  91. - **Works with what you have.** Repo-agnostic and browser-tool-agnostic; web and iOS/iPadOS apps; optional two-way sync with Linear, GitHub Issues, Jira, or Notion. Runs fine in a cloud VM (e.g. Cursor cloud) with just a browser driver.
  92. ---
  93. ### See the output
  94. The agent regenerates a self-contained HTML report at the end of every pass, designed to read like a magazine, not a Kanban board (editorial typography, ink-on-paper palette, no chips or pills). Here is what you instantly get:
  95. | The QA dashboard | A single bug report |
  96. |---|---|
  97. | [![QA dashboard: verdict, then the prioritized bug list](plugins/running-bug-review-board/skills/running-bug-review-board/references/templates/html-report/samples/dashboard-desktop.png)](plugins/running-bug-review-board/skills/running-bug-review-board/references/templates/html-report/samples/dashboard-desktop.png) | [![Bug detail: impact, what's happening vs expected, steps, evidence](plugins/running-bug-review-board/skills/running-bug-review-board/references/templates/html-report/samples/bug-detail-desktop.png)](plugins/running-bug-review-board/skills/running-bug-review-board/references/templates/html-report/samples/bug-detail-desktop.png) |
  98. | **Verdict first, then the prioritized bug list** and recent runs. | **One bug, told for an engineer:** impact → what's happening vs. what should → steps → evidence. |
  99. It is responsive, too: on a phone the dashboard collapses to a single column with a sticky primary action. ([mobile sample](plugins/running-bug-review-board/skills/running-bug-review-board/references/templates/html-report/samples/dashboard-mobile.png) · [design notes](plugins/running-bug-review-board/skills/running-bug-review-board/references/html-report-style-guide.md))
  100. ---
  101. ### Example prompts
  102. Once the skill is installed, just ask your agent in plain language:
  103. ```text
  104. QA this app. Run a manual test plan on mobile and tell me what's broken.
  105. Is phase 3 ready to ship? Give me a YES/NO with the open P0/P1 list.
  106. Drive the signup flow like a brand-new user with stale storage, and file any bugs you find.
  107. Re-test the fixed bugs BUG-007 and BUG-012 on the latest build and update the report.
  108. Run the Interactive Bug Review Board with me on the open backlog.
  109. ```
  110. The skill activates on phrases like *"QA this"*, *"is this ready to ship?"*, *"find the bugs"*, or *"run a test plan"*, so you don't have to name it.
  111. ---
  112. ### Quick start
  113. After [installing](#install), the agent walks itself through:
  114. 1. **Discover the app**: read the product spec / README / phase doc, open bugs, and public routes.
  115. 2. **Plan**: derive real-user scenarios from the spec and the gates.
  116. 3. **Prepare**: environment, test accounts, primary viewport.
  117. 4. **Execute**: drive the app like a customer, capturing evidence.
  118. 5. **File bugs**: `BUG-NNN-*.md` with priority + reproduction steps.
  119. 6. **Sign off**: YES/NO verdict, open P0/P1 list, and a paste-ready handoff.
  120. **No QA folder yet?** The skill ships a scaffolder. After installing it lives in the Skill folder (e.g. `~/.claude/skills/running-bug-review-board/scripts/scaffold-qa.sh`). To run it without installing, clone and call it directly:
  121. ```bash
  122. git clone https://github.com/RayFernando1337/rayfernando-skills.git
  123. bash rayfernando-skills/plugins/running-bug-review-board/skills/running-bug-review-board/scripts/scaffold-qa.sh \
  124. /path/to/your/repo PHASE_NUMBER
  125. ```
  126. This creates `docs/qa/` with the bug template, run-report skeletons, gates checklist, and a per-phase manual test plan. It is idempotent and won't overwrite existing files.
  127. ---
  128. ### Install
  129. Pick the section for the agent you use. Each one installs the same Skill file; they differ only in how the agent discovers it.
  130. #### Claude Code
  131. ```
  132. /plugin marketplace add RayFernando1337/rayfernando-skills
  133. /plugin install running-bug-review-board@rayfernando-skills
  134. ```
  135. To pin a specific release tag, append it to the marketplace add (e.g. `@v0.4.0`). Docs: [code.claude.com/docs/en/plugin-marketplaces](https://code.claude.com/docs/en/plugin-marketplaces).
  136. #### Factory Droid
  137. ```bash
  138. droid plugin marketplace add https://github.com/RayFernando1337/rayfernando-skills
  139. droid plugin install running-bug-review-board@rayfernando-skills
  140. ```
  141. Factory Droid reads the same `.claude-plugin/marketplace.json` Claude Code uses. Docs: [docs.factory.ai/cli/configuration/plugins](https://docs.factory.ai/cli/configuration/plugins).
  142. #### Codex (app, desktop, IDE, and CLI)
  143. On Codex CLI, add the marketplace and install:
  144. ```bash
  145. codex plugin marketplace add RayFernando1337/rayfernando-skills
  146. codex plugin add running-bug-review-board@rayfernando-skills
  147. ```
  148. On older Codex CLI without `plugin add`, open Codex, type `/plugins`, switch to the `rayfernando-skills` tab, and Install. In the app/desktop, use the Plugins / Skills installer and restart Codex so the skill cache reloads. Docs: [developers.openai.com/codex/plugins/build](https://developers.openai.com/codex/plugins/build).
  149. <details>
  150. <summary>Codex shows "invalid description: exceeds maximum length of 1024 characters"?</summary>
  151. You are likely running a cached `running-bug-review-board` 0.3.0 install. Update or reinstall `running-bug-review-board@rayfernando-skills`, then restart Codex (app, desktop, IDE, or CLI) so it refreshes the plugin cache. (0.3.1+ ships Codex-valid metadata and the release pipeline now validates it.)
  152. </details>
  153. #### Cursor
  154. Cursor's `/add-plugin` is reserved for the [cursor.com/marketplace](https://cursor.com/marketplace) listings, so for this repo use the cross-vendor installer. It writes the Skill folder into `~/.cursor/skills/`, which Cursor reads on startup:
  155. ```bash
  156. npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/running-bug-review-board/skills/running-bug-review-board -a cursor
  157. ```
  158. Docs: [cursor.com/docs/skills](https://cursor.com/docs/skills).
  159. #### Cross-vendor: `npx skills add`
  160. The [`vercel-labs/skills`](https://github.com/vercel-labs/skills) installer detects every supported agent CLI on your machine and writes the Skill folder into each one's expected location (Claude Code, Cursor, Codex, Factory Droid, Windsurf, Zencoder, and ~50 others):
  161. ```bash
  162. npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/running-bug-review-board/skills/running-bug-review-board
  163. ```
  164. Add `-a <agent>` to target one tool (`-a cursor`, `-a codex`, `-a droid`) or `--all` for every detected agent.
  165. #### claude.ai (Settings → Features → Skills)
  166. Download `running-bug-review-board.zip` from the [latest release](https://github.com/RayFernando1337/rayfernando-skills/releases/latest) and upload it. To build the zip from a local clone (claude.ai expects a zip whose root contains `SKILL.md`):
  167. ```bash
  168. cd plugins/running-bug-review-board/skills
  169. zip -r ../../../running-bug-review-board.zip running-bug-review-board
  170. ```
  171. #### Manual install (any other agent)
  172. Clone once and symlink the Skill folder into whichever directory your agent reads:
  173. ```bash
  174. git clone https://github.com/RayFernando1337/rayfernando-skills.git ~/Code/rayfernando-skills
  175. ln -sf ~/Code/rayfernando-skills/plugins/running-bug-review-board/skills/running-bug-review-board \
  176. ~/.<agent>/skills/running-bug-review-board
  177. ```
  178. Replace `~/.<agent>/skills/` with your agent's path (`~/.cursor/skills/`, `~/.codex/skills/`, `~/.factory/skills/`, …). The same symlink can be committed inside a project (e.g. under `.claude/skills/` or `.cursor/skills/`) so anyone who clones it picks up the skill.
  179. ---
  180. ### How it works
  181. - **Drives the live app.** The agent works through URLs and clicks; marking PASS from code inspection alone is forbidden.
  182. - **Three hats, one pass.** Every pass wears PM (does it still deliver the promise?), QA (run the user scenarios with evidence), and Engineer (catch invalidated assumptions). Finding gaps is the point.
  183. - **BRB cadence.** Bugs live in a versioned folder with status transitions (`open → in-progress → fixed → verified`). P0/P1/P2 tells the team what to ship and what to defer. Triage happens in a separate **Interactive Bug Review Board** session so triage bias never contaminates discovery.
  184. - **Tool- and repo-agnostic.** Adopts whatever conventions exist and scaffolds folders when there are none. Parallel or sequential QA modes, and when the [`waves`](#waves-wave-engineering-for-agent-teams) skill is installed, the parallel pass runs as a bounded wave: Test-ID coverage gate, structured shard handoffs, tiered verification, cheap-model routing for low-risk shards, and evidence kept on disk instead of in context.
  185. #### Browser & Computer Use
  186. The agent drives the UI with the best driver your environment has, falling back gracefully, so a pass succeeds whether you're in Cursor, another IDE, or a headless cloud VM:
  187. 1. **cursor-ide-browser** MCP (default inside Cursor)
  188. 2. **[Chrome DevTools for agents](https://github.com/ChromeDevTools/chrome-devtools-mcp)** (`chrome-devtools-mcp`): auto-waits for results (fewer flaky races) and adds network / console / Lighthouse / accessibility introspection; can attach to your *real signed-in Chrome* so auth flows don't get bot-flagged
  189. 3. **browser-use** MCP / **Playwright**
  190. 4. **Codex Computer Use** (macOS): a human-fidelity pass that sees, clicks, and types in the *real* app, and the only way to reach a native macOS app
  191. 5. Manual driving with screenshot/console relay
  192. Details and "drive like a human (don't trip the tests)" recipes live in the [browser playbook](plugins/running-bug-review-board/skills/running-bug-review-board/references/browser-playbook.md) and the [Computer Use playbook](plugins/running-bug-review-board/skills/running-bug-review-board/references/computer-use-playbook.md). For iOS/iPadOS apps the skill **orchestrates** and defers simulator driving to the [iOS community's purpose-built skills](plugins/running-bug-review-board/skills/running-bug-review-board/references/ios-simulator-playbook.md), and it never spins up an iOS simulator for a web-only app.
  193. ---
  194. ### What's inside
  195. Each Skill file uses **progressive disclosure**: a lean `SKILL.md` entry point, with references loaded only when needed. Auditing the skill (or asking your own agent to security-check it) starts at:
  196. - [`SKILL.md`](plugins/running-bug-review-board/skills/running-bug-review-board/SKILL.md): the entry point, covering workflow, surfaces, modes, and deliverables.
  197. - [`references/`](plugins/running-bug-review-board/skills/running-bug-review-board/references/): the detailed playbooks (discovery, test plan, browser, Computer Use, iOS, trackers, triage, HTML report, extending).
  198. - [`scripts/`](plugins/running-bug-review-board/skills/running-bug-review-board/scripts/): tiny shell helpers (scaffold a QA folder, list bugs needing tracker sync/pull). No magic; the agent does the work.
  199. ---
  200. ## bootstrap-ios: load the iOS agent stack
  201. `bootstrap-ios` is a meta-skill for Apple-platform app work. It gives agents one
  202. place to start before touching iOS, iPadOS, macOS, Swift, SwiftUI, SwiftData,
  203. Core Data, Swift Testing, Xcode build/test/debug, Simulator, or App Intents.
  204. It does not try to paste every community Swift rule into context. It routes the
  205. agent to the right focused references and tools:
  206. - Paul Hudson / Hacking with Swift skill packs for SwiftUI, concurrency,
  207. Swift Testing, and SwiftData.
  208. - Antoine van der Lee / SwiftLee skill packs, including Xcode Build
  209. Optimization.
  210. - Official OpenAI build iOS/macOS plugin references.
  211. - Krzysztof Zablocki's public Merowing rules and rule-loader approach.
  212. - AppCreator buildability ideas.
  213. - XcodeBuildMCP for parseable Xcode build, test, simulator, and debug flows.
  214. **Install the skill:**
  215. ```bash
  216. /plugin install bootstrap-ios@rayfernando-skills
  217. ```
  218. **Cursor / cross-vendor install:**
  219. ```bash
  220. npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/bootstrap-ios/skills/bootstrap-ios -a cursor
  221. ```
  222. **Optional one-command helper, after installing or cloning:**
  223. ```bash
  224. bash plugins/bootstrap-ios/skills/bootstrap-ios/scripts/bootstrap-ios-skills.sh --dry-run --agent cursor
  225. ```
  226. Run without `--dry-run` only when you really want to install the public
  227. community skill packs into that agent environment. After a real install the
  228. helper **verifies every expected skill landed and is complete**: each skill
  229. must have a `SKILL.md` under a known skill root, and every `references/`,
  230. `scripts/`, and `assets/` file it cites must exist on disk. The script fails
  231. loudly with reinstall instructions (`npx skills add <url> --full-depth`) if
  232. any skill is missing entirely or installed shallow — either way agents would
  233. follow a `references/` pointer into nothing and silently degrade. Pass
  234. `--skip-verify` to opt out.
  235. ---
  236. ## swiftui-animation-match: interaction-to-animation matching
  237. > **`swiftui-animation-match`** turns a vaguely felt interaction wish — "saving should feel more satisfying", "the empty screen is boring while it loads" — into either a specific, proven SwiftUI animation pattern from a curated catalog, or the deliberate decision that the system already covers it.
  238. Most of the time you know the *feeling* you want, not the animation's name.
  239. This skill encodes the judgment step: name the interaction moment (waiting,
  240. confirming, toggling, browsing, revealing…), check what modern SwiftUI gives
  241. you free (springs, `.symbolEffect`, `.contentTransition`, `.sensoryFeedback`,
  242. Liquid Glass chrome on iOS 26+), and only then match into cataloged custom
  243. motion that earns its place. The catalogs are a menu, not a quota — the skill
  244. is explicitly biased against forcing an animation where the platform already
  245. shines.
  246. ### What's in the first catalog
  247. The launch catalog covers **[Shubham0812/SwiftUI-Animations](https://github.com/Shubham0812/SwiftUI-Animations)**
  248. (Apache-2.0, iOS 17+): 30 self-contained SwiftUI animations plus 7 Metal
  249. shader effects, every one read at source level and cataloged with its exact
  250. repo path, the load-bearing technique (`matchedGeometryEffect` scatter,
  251. `animatableData` shape morphs, traveling `.trim` windows, `layerEffect`
  252. shader wiring…), the spring/duration values that create the feel, lift notes
  253. (dependencies, difficulty, known bugs to fix on lift), and search keywords.
  254. Entries are grouped by interaction moment: wait states, determinate
  255. progress, action feedback, toggles with identity, card decks and carousels,
  256. text heroes, input chrome, reveals, and shader effects.
  257. ### Built to grow
  258. Send it another animation repo and it becomes one more catalog file:
  259. [`adding-a-source.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/adding-a-source.md)
  260. documents the repeatable recipe — stage and pin the repo, fan out parallel
  261. read-only workers over folder slices (a wave, if `waves` is installed), each
  262. returning entries in the fixed block format, then assemble, register in
  263. [`sources.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/sources.md),
  264. and spot-check claims against the pinned commit.
  265. ### Example prompts
  266. ```text
  267. Plan the onboarding flow for my recipe app — where would animation actually help, and which patterns?
  268. The download button in my app feels dead. What's a proven pattern for inline download progress?
  269. I want deleting a note to feel consequential. What fits?
  270. Users don't notice the app is syncing — suggest something calm, not a spinner.
  271. Add https://github.com/<owner>/<another-animation-repo> to the animation-match skill.
  272. ```
  273. ### Install swiftui-animation-match
  274. **Claude Code:** `/plugin install swiftui-animation-match@rayfernando-skills`
  275. **Cursor / cross-vendor:**
  276. ```bash
  277. npx skills add https://github.com/RayFernando1337/rayfernando-skills/tree/main/plugins/swiftui-animation-match/skills/swiftui-animation-match -a cursor
  278. ```
  279. ### What's inside
  280. - [`SKILL.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/SKILL.md): the matcher — moment-first workflow, system-vs-custom decision rules, restraint rules, adaptation posture.
  281. - [`references/matching-playbook.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/matching-playbook.md): the moment taxonomy, the system-first checklist, worked examples, anti-patterns.
  282. - [`references/catalog-shubham0812-swiftui-animations.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/catalog-shubham0812-swiftui-animations.md): the 37-entry catalog with shared-infrastructure notes and a lift checklist.
  283. - [`references/sources.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/sources.md): source index with pinned commits, licenses, and the staleness policy.
  284. - [`references/adding-a-source.md`](plugins/swiftui-animation-match/skills/swiftui-animation-match/references/adding-a-source.md): the recipe for cataloging the next repo.
  285. ---
  286. ## Repo structure
  287. ```
  288. rayfernando-skills/
  289. ├── .claude-plugin/
  290. │ └── marketplace.json # marketplace catalog
  291. ├── plugins/
  292. │ ├── waves/ # Cursor variant (parallel Task tool subagents)
  293. │ │ ├── .claude-plugin/
  294. │ │ │ └── plugin.json # plugin manifest
  295. │ │ └── skills/
  296. │ │ └── waves/
  297. │ │ ├── SKILL.md
  298. │ │ ├── references/ # examples, handoff-format, verification
  299. │ │ └── evals/ # evals.json + fixtures + eval README
  300. │ ├── waves-codex/ # Codex variant (subagents + config.toml)
  301. │ │ ├── .claude-plugin/
  302. │ │ │ └── plugin.json
  303. │ │ └── skills/
  304. │ │ └── waves-codex/
  305. │ │ ├── SKILL.md
  306. │ │ ├── agents/openai.yaml
  307. │ │ ├── references/ # adaptation-notes, examples, handoff-format, recommended-config, verification
  308. │ │ └── evals/ # evals.json + fixtures + eval README
  309. │ ├── running-bug-review-board/
  310. │ │ ├── .claude-plugin/
  311. │ │ │ └── plugin.json
  312. │ │ └── skills/
  313. │ │ └── running-bug-review-board/
  314. │ │ ├── SKILL.md # lean entry point; references load on demand
  315. │ │ ├── references/ # loaded on demand
  316. │ │ │ ├── workflow.md
  317. │ │ │ ├── discovering-the-app.md
  318. │ │ │ ├── test-plan.md
  319. │ │ │ ├── test-accounts.md
  320. │ │ │ ├── session-hygiene.md
  321. │ │ │ ├── browser-playbook.md
  322. │ │ │ ├── computer-use-playbook.md
  323. │ │ │ ├── ios-simulator-playbook.md
  324. │ │ │ ├── parallel-coordinator.md
  325. │ │ │ ├── sequential-wrapup.md
  326. │ │ │ ├── bug-filing.md
  327. │ │ │ ├── gate-merge.md
  328. │ │ │ ├── issue-trackers.md
  329. │ │ │ ├── brb-interactive.md
  330. │ │ │ ├── triage-heuristics.md
  331. │ │ │ ├── html-report-style-guide.md
  332. │ │ │ ├── extending-the-skill.md
  333. │ │ │ └── templates/ # bug, test-plan, run-report, merge, BRB,
  334. │ │ │ │ # qa-config, and html-report/ + samples/
  335. │ │ │ └── html-report/
  336. │ │ └── scripts/
  337. │ │ ├── scaffold-qa.sh # create the QA folder layout
  338. │ │ ├── bugs-needing-sync.sh # list bugs missing a tracker ID
  339. │ │ └── bugs-needing-pull.sh # list bugs with stale tracker sync
  340. │ ├── bootstrap-ios/ # iOS/macOS router skill + optional installer helper
  341. │ │ ├── .claude-plugin/
  342. │ │ │ └── plugin.json
  343. │ │ └── skills/
  344. │ │ └── bootstrap-ios/
  345. │ │ ├── SKILL.md
  346. │ │ ├── references/ # workflow, skill map, XcodeBuildMCP, sources
  347. │ │ └── scripts/
  348. │ │ └── bootstrap-ios-skills.sh
  349. │ └── swiftui-animation-match/ # interaction-to-animation matcher
  350. │ ├── .claude-plugin/
  351. │ │ └── plugin.json
  352. │ └── skills/
  353. │ └── swiftui-animation-match/
  354. │ ├── SKILL.md
  355. │ └── references/ # matching playbook, catalogs, sources, adding-a-source
  356. ├── scripts/
  357. │ ├── validate-skill-metadata.py # release-time Codex-metadata validator
  358. │ └── validate-skill-evals.py # release-time skill-eval validator
  359. ├── .github/workflows/release.yml # builds the claude.ai zip on tag push
  360. ├── CHANGELOG.md
  361. ├── LICENSE
  362. └── README.md
  363. ```
  364. ---
  365. ## Contributing
  366. Issues and PRs welcome. If you've used the Skill file on a real project, a short writeup of a lesson learned is the most valuable contribution: a session-hygiene rule that saved you, a bug that reveals a new real-user pattern, or a playbook for an auth provider this skill doesn't cover yet. See [`extending-the-skill.md`](plugins/running-bug-review-board/skills/running-bug-review-board/references/extending-the-skill.md) for how the skill grows without rewrites. For the `waves` variants, changes to orchestration guidance should be checked against the skill evals (`evals/README.md` in each variant): run the with-skill vs baseline A/B and report the delta.
  367. Style guide: SKILL.md body under ~500 lines with references one level deep; imperative voice; third-person frontmatter description; examples from real projects; no time-sensitive copy (use "old patterns" sections instead).
  368. ---
  369. ## Background
  370. Ray spent 12 years at Apple working across many parts of the system. The lesson he carried away: finding the bugs your users would hit first comes from a repeatable workflow, and he has been refining that cadence on his own projects ever since. The Skill files in this collection are his encoding of that work, and `waves` generalizes the same instinct, *verify before you trust*, from QA passes to whole teams of agents.
  371. ---
  372. ## Changelog
  373. This project follows [Semantic Versioning](https://semver.org/) and [Keep a Changelog](https://keepachangelog.com/). Recent highlights: run-shape triage, dependency-aware dispatch, and missing-role fallbacks in both `waves` variants (adapted from a public deep-research skill, re-verified against live Cursor/Codex docs); skill evals and deeper paper grounding for `waves`; entropy-first decomposition and per-slice model routing; the QA skill's parallel pass running as a wave; plus a Computer Use + Chrome DevTools driver playbook, an editorial HTML report (Zite + Dieter Rams), and confirmed two-way issue-tracker sync. Full history in [`CHANGELOG.md`](CHANGELOG.md).
  374. ---
  375. ## License
  376. [Apache License 2.0](LICENSE), copyright 2026 Ray Fernando. The Skill files here can be used, modified, and redistributed in any project, including commercial and internal use. Attribution is appreciated but not required.

Ratings and comments

Sign in to rate this skill.

Sign in

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