# creative-ads-explorer

Adopt this skill: https://proskills.md/skills/other/dkeken-codex-skills-alternative-skills-creative-ads-explorer

Page: https://proskills.md/skills/other/dkeken-codex-skills-alternative-skills-creative-ads-explorer
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/creative-ads-explorer/SKILL.md
size: 4705
sha: 416bceeb18b090ccbd03e07e193fd5e8bca088af
upstream: https://github.com/dkeken/codex-skills-alternative/blob/main/skills/creative-ads-explorer/SKILL.md

````text
---
name: creative-ads-explorer
description: Rapidly generate up to 25 distinct ad creative hypotheses for testing. Produces a matrix of angles (pain, benefit, social proof, urgency, curiosity, comparison) x formats (static, carousel hook, UGC-style, bold-text overlay) with headline, visual prompt, and rationale for each, then generates the visuals with any image tool. Use when the user wants "ad variations", "ad concepts", "creative testing batch", "give me 25 ads", or paid-social creative ideation. Part of the Creative Production set.
---

# Creative — Ads Explorer

Pump out a broad, diverse batch of ad hypotheses for A/B/n testing. This is the *exploration* stage: quantity + diversity beat polish. The goal is to cover the message space so the market tells you what works — not to perfect one ad.

## When to use
- Launching paid social/display and need a test batch.
- An existing ad is fatiguing and you need fresh angles.
- Validating which *message* resonates before investing in production.

## When NOT to use
- You already know the winning angle and just need it finished → `creative-polish`.
- You're merchandising a specific discount/bundle → `creative-offer` (sharper for that).
- No visual direction exists and brand look matters → lock it via `creative-explore` first.

## Inputs (ask only what's missing)
- **Product + core offer** (what they get).
- **Audience + their #1 pain or desire** (the emotional hook).
- **Platform**: Meta, TikTok, Google Display, X, YouTube — sets aspect + length limits.
- **Locked visual direction** (from `creative-explore`) if available, so the batch stays on-brand.

## The angle × format matrix
Build hypotheses by crossing **angles** with **formats**:
- **Angles**: pain, benefit, social-proof, urgency/scarcity, curiosity/pattern-interrupt, comparison/vs-incumbent, founder/origin story, transformation/before-after.
- **Formats**: static hero, hook-frame (thumb-stopper top third), UGC mock (handheld, casual), bold-text overlay, before/after split, problem→solution 2-panel.

Not every cell is worth filling — pick the combinations most likely to resonate for THIS audience.

## Workflow
1. Pick the count (default 12, max 25). Choose the highest-potential angle×format cells.
2. For each: **headline** (≤7 words), subtext, **visual prompt**, and *why it might win* (the hypothesis being tested).
3. Kill near-duplicates aggressively — two ads testing the same idea waste spend.
4. Generate visuals with your image-generation tool at platform ratio (`1024x1024` square, `1792x1024` landscape, or vertical for stories/TikTok). Save to `./creative/ads/<NN>-<angle>.png`.
5. Output a ranked table; mark the top 3-5 to launch first and state what each one is testing.

## Worked example
Product: AI meeting-notes app. Audience pain: "I forget action items." Platform: Meta feed (1:1).
```
| #  | angle      | format       | headline                   | tests hypothesis              | pri  |
|----|------------|--------------|----------------------------|-------------------------------|------|
| 1  | pain       | hook-frame   | "Forgot the action item again?" | pain-first beats feature  | HIGH |
| 2  | benefit    | static hero  | "Every decision, captured"  | calm-benefit framing          | HIGH |
| 3  | social     | UGC mock     | "My team stopped taking notes" | testimonial credibility    | HIGH |
| 4  | comparison | 2-panel      | "Otter vs us"               | switcher intent               | MED  |
| 5  | urgency    | bold-text    | "Your next meeting starts in 10" | urgency relevance        | LOW  |
```
Launch 1-3 first (distinct emotional levers); 4 if switcher traffic exists.

## Quality bar
- Each ad tests a *different* hypothesis — you can name what you'd learn from each.
- Headlines respect platform character limits (Meta primary ≤125, headline ≤40, etc.).
- Text baked into images is short and exact; passed verbatim in the prompt.
- Top picks are justified, not arbitrary.

## Common pitfalls
- **Variation theater** — 25 near-identical ads. Diversity of *angle* is the point.
- **Fabricated proof** — never invent stats, reviews, or testimonials. Flag any the user must supply real.
- **Ignoring platform specs** — wrong aspect/length gets rejected or cropped badly.
- **Polishing too early** — these are disposable hypotheses; only winners go to `creative-polish`.

## Handoff
Winning ads (post-test or top-ranked) → `creative-polish` for production finish. On-brand consistency check → reuse the `creative-explore` stub.

## Tooling
Needs a text-to-image tool to render. Without one, deliver the full matrix (headlines + prompts + hypotheses) and the user generates manually.
````

## File: README.md
upstream: https://github.com/dkeken/codex-skills-alternative/blob/main/README.md

````text
# codex-skills-alternative

An open, portable reimplementation of two Codex role plugins — **Creative Production** and **Product Design** — as 19 vendor-neutral [Agent Skills](https://code.claude.com/docs/en/skills) (`SKILL.md`): 17 task skills + 2 orchestrators that route to them.

> **Why this exists.** OpenAI announced the *Creative Production* and *Product Design* plugins for Codex (June 2026), but they ship **only inside Codex** through the in-app Plugin Directory — and their source is not published. This repo brings the same workflows to **every other agent that OpenAI doesn't serve**: Claude Code, opencode, Cursor, Gemini CLI, GitHub Copilot. It's an **independent, by-the-spec reimplementation** written from the public descriptions — no proprietary prompts copied. (Already on Codex? You likely don't need this — use the official plugins. See the Codex note below.)

Each skill is **tool-agnostic**: it references generic capabilities ("an image-generation tool", "a browser-automation tool", "a web-fetch tool") so you can wire it to whatever you have — DALL·E / Imagen / FLUX / SD / Midjourney for images, Playwright for the browser, any fetch/search MCP for the web.

## What's inside

### Orchestrators (2 skills)
Start here — they read your request and route to the right sub-skill.

| Skill | What it does |
|---|---|
| `creative-production` | Routes a creative brief to the right `creative-*` sub-skill |
| `product-design` | Routes a design goal to the right `design-*` sub-skill |

### Creative Production (8 skills)
Turn a brief into reviewable visual assets.

| Skill | What it does |
|---|---|
| `creative-explore` | Propose 3-6 named visual directions + one reference image each; lock one |
| `creative-moodboard` | Build 2-4 visual territories with sample tiles for team alignment |
| `creative-positioning` | Map business positioning → a concrete visual language spec |
| `creative-offer` | Merchandise a specific offer/value-prop into hero visuals |
| `creative-ads-explorer` | Generate up to 25 diverse ad hypotheses (angle × format matrix) |
| `creative-scene` | Realistic product-in-use lifestyle scenes |
| `creative-shot` | Consistent multi-angle product shot set (ecommerce/PDP) |
| `creative-polish` | Finish a chosen visual (fix artifacts, grade, conform aspect) |

### Product Design (9 skills)
Turn early ideas into reviewable prototypes.

| Skill | What it does |
|---|---|
| `design-get-context` | Clarify the brief first (goal, user, success, scope) → `context.md` |
| `design-research` | Competitor scan + UX pattern research + pain mining |
| `design-audit` | Heuristic audit of an existing UI (hierarchy, a11y, conversion) |
| `design-ideate` | 2-4 structurally different UI directions with tradeoffs |
| `design-image-to-code` | Reference image → working local frontend (screenshot-verified) |
| `design-url-to-code` | Live site → editable local frontend in your stack |
| `design-prototype` | Wire static screens into a clickable, runnable prototype |
| `design-qa` | Conformance check: implementation vs design + requirements |
| `design-share` | Publish a runnable prototype and return a shareable link |

### Suggested flows
- **Creative:** `explore` / `moodboard` / `positioning` → `scene` · `shot` · `ads-explorer` · `offer` → `polish`
- **Design:** `get-context` → `research` · `audit` → `ideate` → `image-to-code` · `url-to-code` → `prototype` → `qa` → `share`

## Installation

A skill is just a folder with a `SKILL.md`. "Installing" = putting that folder where your agent looks for skills. Pick your tool below.

### Quick install (any tool)

```bash
git clone https://github.com/DKeken/codex-skills-alternative.git
cd codex-skills-alternative
./install.sh            # auto-detects installed agents, installs globally
./install.sh --help     # see options (per-tool, project scope, dry-run)
```

The script copies each `skills/<name>/` folder into the right directory for every agent it detects. Manual instructions per tool follow.

### Codex (as a real plugin) — usually unnecessary
**If you're on Codex, you probably don't need this.** OpenAI ships the official *Creative Production* and *Product Design* plugins in the in-app Plugin Directory ("Curated by OpenAI") — if they're available in your region/plan, use those; they're more polished and wire up Figma/Canva/Shutterstock/Picsart/Fal for you.

This bundle is worth installing on Codex only as a **fallback** (official not rolled out to you yet) or if you want an **open, vendor-neutral, hackable** version with no proprietary app dependencies. The repo is still a valid Codex plugin:

```bash
git clone https://github.com/DKeken/codex-skills-alternative.git
codex plugin marketplace add ./codex-skills-alternative
codex plugin install codex-skills-alternative@codex-skills-alternative-marketplace
```
Or skip the plugin and just copy the skills (below) — same result, no marketplace.

### Claude Code
Source: [official docs](https://code.claude.com/docs/en/skills).

| Scope | Path |
|---|---|
| Personal (all projects) | `~/.claude/skills/<name>/SKILL.md` |
| Project (committed to repo) | `.claude/skills/<name>/SKILL.md` |

```bash
# Personal install (all 19)
mkdir -p ~/.claude/skills
cp -R skills/* ~/.claude/skills/

# Project install (this repo only)
mkdir -p .claude/skills && cp -R skills/* .claude/skills/
```
Claude Code watches the directory live — no restart needed. Invoke with `/design-get-context` or let it auto-trigger by description.

### opencode / Codex CLI
opencode and Codex read the universal `.agents/skills/` path plus their own dirs.

| Tool | Personal path |
|---|---|
| opencode | `~/.config/opencode/skills/<name>/SKILL.md` |
| Codex CLI | `~/.codex/skills/<name>/SKILL.md` |
| Universal (both + others) | `~/.agents/skills/<name>/SKILL.md` |

```bash
# opencode (global)
mkdir -p ~/.config/opencode/skills && cp -R skills/* ~/.config/opencode/skills/

# Codex CLI (global)
mkdir -p ~/.codex/skills && cp -R skills/* ~/.codex/skills/

# Or the portable path both pick up:
mkdir -p ~/.agents/skills && cp -R skills/* ~/.agents/skills/
```
Restart Codex after copying so it picks up new skills.

### Cursor
Source: [Cursor docs](https://cursor.com/docs/skills). Cursor is **project-scoped** (no personal dir) but also reads `~/.cursor/skills/` and, for compatibility, `.claude/skills` / `.codex/skills` / `.agents/skills`.

| Scope | Path |
|---|---|
| Project | `.cursor/skills/<name>/SKILL.md` |
| Global | `~/.cursor/skills/<name>/SKILL.md` |

```bash
# Project install
mkdir -p .cursor/skills && cp -R skills/* .cursor/skills/
```
Then reload: `Cmd/Ctrl+Shift+P` → "Developer: Reload Window". Skills appear in Settings → Rules → "Agent Decides". Invoke with `/design-audit` or by description.

You can also import from GitHub: Settings → Rules → Add Rule → Remote Rule (GitHub) → paste this repo URL.

### Gemini CLI / GitHub Copilot / others
These follow the same `SKILL.md` standard and read `~/.agents/skills/` (or their vendor dir). Use the universal path:
```bash
mkdir -p ~/.agents/skills && cp -R skills/* ~/.agents/skills/
```

### Path reference

| Agent | Personal | Project |
|---|---|---|
| Claude Code | `~/.claude/skills/` | `.claude/skills/` |
| opencode | `~/.config/opencode/skills/` | `.opencode/skills/` or `.agents/skills/` |
| Codex CLI | `~/.codex/skills/` | `.codex/skills/` or `.agents/skills/` |
| Cursor | `~/.cursor/skills/` | `.cursor/skills/` |
| Universal | `~/.agents/skills/` | `.agents/skills/` |

## Wiring the tools

These skills name capabilities generically. Map them to whatever your agent has:

| Skill needs | Wire to (examples) |
|---|---|
| Image generation / edit | DALL·E, GPT-Image, Gemini Imagen, FLUX, Stable Diffusion, Midjourney, or any image MCP/CLI |
| Browser automation | Playwright MCP, Puppeteer, Chrome DevTools |
| Web fetch / search | any fetch/search MCP, `curl`, Tavily, Exa, Firecrawl |
| Vision / image read | your agent's native image-reading tool |

If a capability is missing (e.g
````
