Other

Make motion graphics and short videos with a coding agent: describe the video, get an HTML composition, preview it and render an MP4 locally. Built on the open-source HyperFrames skills by HeyGen (https://github.com/heygen-com/hyperframes, Apache-2.0), imported unmodified, plus the Playwright MCP server for capturing web pages as source material. **Start** with any video request ("make a 10-second logo sting", "turn this landing page into a promo"); the `hyperframes` skill routes it to the right workflow. **Prerequisites:** Node.js 22+, ffmpeg and a local Chrome/Chromium. Rendering is local and needs no API key. Generated voice-over is optional and goes through the `heygen` CLI (its own sign-in). **Not affiliated with HeyGen.** Do not combine with another video framework's setup in one project: the `hyperframes` skill takes every video request.

• 0 agents
• 10 skills
• 1 MCP server
• 0 files

Reverse engineer shipped software from a coding agent with REA (Reverse Engineer Anything): native binaries, JavaScript and Electron apps, .NET assemblies, Android APKs, firmware, WebAssembly, EVM bytecode, saved network captures and running browser pages. Every conclusion comes back with its evidence and its unknowns, so the agent can explain how a feature works and build a similar one. **Start** by asking about a target, for example: "Explain how search works in /Applications/Notes.app and show the evidence". The `reverse-engineer-anything` skill picks the right REA tool for the target, works summary-first and keeps a finding ledger; the `rea` MCP server does the analysis locally. **Third-party, included unmodified:** the `reverse-engineer-anything` skill (with its reference guides) and the `rea-agents` MCP server, both from https://github.com/morluto/rea (MIT). Not affiliated with the REA authors. **Prerequisites:** Node.js 22.19+, 24.11+ or 26+ (the MCP server runs with `npx`). Static JavaScript, .NET, Go and archive inspection need nothing else. Native decompilation needs Hopper, Ghidra (free) or IDA, installed by you; Android needs headless JADX and a full JDK; firmware needs Binwalk or Unblob; some targets need WABT, pwntools or a Chrome-family browser. No account or API key; Hopper and IDA are paid products. For software you own or are authorized to examine: security and malware research, interoperability, debugging, CTFs. Not for circumventing DRM, licence checks or anti-cheat, or for copying proprietary code — the setup's rules hold the agent to that.

• 0 agents
• 1 skill
• 1 MCP server
• 0 files

Run the operational side of a product from a coding agent: errors in Sentry, product analytics and feature flags in PostHog, payments in Stripe, and one health check that reads all three together. **Start** with `/product-health-check` for a combined picture of the last day or week, or ask directly: "debug this Sentry issue", "why did sign-ups drop", "add analytics events to this feature", "set up an alert". **You sign in to each service on first use.** The three MCP servers are the vendors' hosted ones and use OAuth: Sentry (https://mcp.sentry.dev/mcp), PostHog (https://mcp.posthog.com/mcp) and Stripe (https://mcp.stripe.com). Nothing works for a service until you have signed in to it; the services you do not use can stay signed out. PostHog bills its AI-powered tools as PostHog AI usage. **Third-party skills, imported unmodified:** `sentry-get-started`, `sentry-instrument`, `sentry-debug-issue`, `sentry-create-alert` from https://github.com/getsentry/sentry-for-ai (MIT); `instrument-product-analytics`, `instrument-feature-flags`, `querying-posthog-data`, `building-a-dashboard`, `investigate-metric` from https://github.com/PostHog/skills (MIT, marked by PostHog as under construction). Stripe is used through its MCP server only. Not affiliated with Stripe, Sentry or PostHog. These servers can change live data. The setup's rules make the agent read by default and ask before every write; prefer Stripe test mode and restricted access while you try it.

• 0 agents
• 10 skills
• 3 MCP servers
• 0 files

Build and polish web UI that does not look templated: an aesthetic direction before the first component, React structure and performance, purposeful motion, and a review against interface guidelines and worst-case data before shipping. **Skills, all imported unmodified:** - `frontend-design` from https://github.com/anthropics/skills (Apache-2.0): design direction for new UI. - `redesign-existing-projects` from https://github.com/leonxlnx/taste-skill (MIT): audit and upgrade an existing UI. - `web-design-guidelines`, `vercel-react-best-practices`, `vercel-composition-patterns` from https://github.com/vercel-labs/agent-skills (MIT): UI review, React and Next.js performance, component APIs. - `emil-design-eng`, `animate`, `review-animations`, `break-ui` from https://github.com/emilkowalski/skills (MIT): interaction polish, motion, and stress-testing a component with worst-case data. The Playwright MCP server lets the agent open the page and look at what it built. **Start** with a UI request ("design a pricing page", "redesign this dashboard", "review my UI", "break this card component"). **Prerequisites:** Node.js for the Playwright MCP server and a running dev server to look at; nothing else. `web-design-guidelines` fetches its rules from GitHub when it runs. **Not affiliated with the skills' authors.** The React skills assume React or Next.js; the design skills work with any stack.

• 0 agents
• 9 skills
• 1 MCP server
• 0 files

A full SEO and GEO toolkit for a coding agent: site-wide and single-page audits, technical SEO and Core Web Vitals, content and E-E-A-T, schema markup, sitemaps, hreflang, local and e-commerce SEO, backlinks, topic clusters, content briefs, and readiness for AI search and AI agents. **Start** with `/seo audit <url>` for a scored, prioritized site audit, `/seo page <url>` for one page, or any of the 26 skills directly (`/seo-technical`, `/seo-schema`, `/seo-geo`, …). The audit fans out to 19 specialist subagents. **This is a fork of claude-seo** by AgriciDaniel (https://github.com/AgriciDaniel/claude-seo, MIT), repackaged so it works as plain skills instead of a Claude Code plugin: the Python toolkit is bundled inside the `seo` skill and the paths that pointed at the plugin root point at that skill instead. Nothing else is changed; the fork's README lists the differences. Not affiliated with or endorsed by the upstream author. **Prerequisites:** Python 3.10+. On first use the toolkit asks to create its own virtual environment and install its Python packages (`setup`); the agent asks you before doing that. A local Chromium is optional (rendering and screenshots). **Optional paid or account-based data:** Google Search Console, PageSpeed and GA4 credentials, DataForSEO, Moz, Bing Webmaster and image generation each unlock extra skills and are configured by you; everything else works without an account. **Size:** 26 skills and 19 agents, so it needs a plan that allows that many in one setup and cannot be merged whole into a free-plan project. The subagent tool lists and models are set for Claude Code.

• 19 agents
• 26 skills
• 0 MCP servers
• 0 files

Build, polish and upgrade React Native apps with a coding agent, using the skills maintained by the Expo team and by Callstack. **Start** with any Expo or React Native request; the `expo-overview` skill is the entry point for Expo work and routes to the others. Covered here: navigation with Expo Router and React Navigation, native-feeling UI, data fetching, animation, development builds, performance, and upgrading the Expo SDK or React Native. **Third-party skills, imported unmodified:** `expo-overview`, `expo-router`, `expo-native-ui`, `expo-data-fetching`, `expo-animation`, `expo-dev-client`, `expo-upgrade` from https://github.com/expo/skills (MIT); `react-native-best-practices`, `react-navigation`, `upgrading-react-native` from https://github.com/callstackincubator/agent-skills (MIT). `expo-overview` also mentions Expo skills that are not part of this setup; add them from the same repository when you need them. **MCP server:** Expo's hosted MCP server (https://mcp.expo.dev/mcp) for current Expo documentation and EAS; you sign in with your Expo account on first use, and some of its tools need an EAS plan. **Prerequisites:** Node.js; Xcode or Android Studio for running on a simulator or device. Not affiliated with Expo or Callstack.

• 0 agents
• 10 skills
• 1 MCP server
• 0 files

Write, test, refactor and review Terraform with a coding agent, using HashiCorp's own skills and registry data, with a hard stop before anything touches real infrastructure. **Start** with a Terraform request ("write a module for…", "add tests", "split this configuration into modules", "import these existing resources") or `/terraform-plan-review` to check a plan for destructive and risky changes before applying it. **Third-party skills, imported unmodified** from https://github.com/hashicorp/agent-skills (MPL-2.0; source at that address): `terraform-style-guide`, `terraform-test`, `refactor-module`, `terraform-search-import`, `terraform-stacks`, `terraform-policy`. The `terraform-plan-review` skill is written by Athenode. **MCP server:** HashiCorp's Terraform MCP server (https://github.com/hashicorp/terraform-mcp-server, MPL-2.0) gives current provider, module and policy documentation from the Terraform Registry. It runs locally in Docker and needs no account for the public registry; HCP Terraform and Terraform Enterprise tools need your own token and are not configured here. **Prerequisites:** the `terraform` CLI and Docker. Not affiliated with HashiCorp.

• 0 agents
• 7 skills
• 1 MCP server
• 0 files

Work with a PostgreSQL database from a coding agent: inspect the real schema, write and tune queries against actual plans, and review migrations for locks and data loss before they run. **Start** with `/postgres-query-review <query or file>` to tune a query against its real plan, `/postgres-migration-review <file>` before applying a migration, or just ask about the schema. The `supabase-postgres-best-practices` skill loads whenever tables, indexes or queries are written. **Database access** goes through DBHub (https://github.com/bytebase/dbhub, MIT), run locally with `npx`. Export `DATABASE_URL` (for example `postgres://user:password@localhost:5432/app`) before starting your agent. **Use a read-only database role**: the setup's rules make the agent ask before any write, but the role is the real guard. Point it at a development or staging database, not production. **Third-party skill, imported unmodified:** `supabase-postgres-best-practices` from https://github.com/supabase/agent-skills (MIT) — written for Postgres running anywhere, not only on Supabase. The two review skills are written by Athenode. Not affiliated with Supabase or Bytebase. **Prerequisites:** Node.js and a reachable Postgres database.

• 0 agents
• 3 skills
• 1 MCP server
• 0 files

Test a running web application through a real browser with a coding agent: exploratory testing with reproducible bug reports, console and network errors, performance traces, and regression tests written from the flows that were verified by hand. **Start** with `/web-qa-explore <url>` (for example your local dev server) to explore the app and get a bug report, or `/web-qa-regression <flow>` to turn a flow into an end-to-end test in the project's own test framework. Browser work is delegated to the `web-qa-tester` subagent, so page snapshots stay out of the main conversation. **MCP servers:** Playwright MCP (https://github.com/microsoft/playwright-mcp, Apache-2.0) drives the browser; Chrome DevTools MCP (https://github.com/ChromeDevTools/chrome-devtools-mcp, Apache-2.0) adds performance traces and network and console inspection, and is configured with Google's usage statistics turned off. **Prerequisites:** Node.js and a local Chrome. No account or API key. The skills and the agent are written by Athenode. For testing applications you own or are authorized to test.

• 1 agent
• 2 skills
• 2 MCP servers
• 0 files

A disciplined everyday engineering loop for a coding agent: stress-test the plan, write it down, build it test-first, diagnose bugs with a reproducing signal, and review the diff before it is called done. Built on Matt Pocock's skills (https://github.com/mattpocock/skills, MIT), imported unmodified, plus the Context7 MCP server for current library documentation. **Start** by running `/setup-matt-pocock-skills` once per repository (it records your issue tracker and doc layout). Then: `/grill-me` to sharpen a plan, `/to-spec` to publish it to the issue tracker, `/implement` to build it with `tdd` and finish with `code-review`; `diagnosing-bugs` for anything broken or slow, `codebase-design` for module boundaries, `research` to gather facts in the background. **Prerequisites:** none for the skills; the issue-tracker steps use whatever tracker CLI the setup step configures (for GitHub, `gh`). Context7 works without a key, with lower rate limits. **Not affiliated with Matt Pocock.** `to-spec` writes to your issue tracker, not to Athenode specifications. In Claude Code the `code-review` skill shares its name with a built-in command.

• 0 agents
• 10 skills
• 1 MCP server
• 0 files

Defensive security review of your own codebase with a coding agent: code review for vulnerabilities, dependency and supply-chain audit, secret scanning, CI workflow and IaC checks, and threat modeling. **Start** with `/security-audit` (whole repository, a path, or the current diff). It fans out to three subagents — code reviewer, dependency auditor and a verifier that tries to disprove each finding — and returns one report with only the findings that survived. **Works with no account.** `/security-scan` runs whichever open-source scanners are installed (semgrep, osv-scanner, gitleaks, trivy) and says which are missing; the review skills need nothing. The Socket MCP server (remote, sign-in on first use) scores dependencies. **Third-party skills, imported unmodified:** `security-review` and `gha-security-review` from https://github.com/getsentry/skills (Apache-2.0; reference material based on the OWASP Cheat Sheet Series, CC BY-SA 4.0), `owasp-security` from https://github.com/agamm/claude-code-owasp (MIT), `stride-analysis-patterns` from https://github.com/wshobson/agents (MIT). Not affiliated with their authors. For reviewing code you own or are authorized to test; it contains no offensive tooling.

• 3 agents
• 6 skills
• 1 MCP server
• 0 files