Creative Patterns — Blueprint

Creative intelligence notebooks for paid growth.

A portable, Markdown-native workspace that captures the creatives your ad platforms generate, connects them to performance data, and turns the messy results into reusable patterns, AI-ready runbooks, and import-ready next tests.

0. North Star

Product statement

Creative Patterns is a simple Markdown workspace and Chrome extension that captures paid ad creatives, connects them to performance data, and turns the learnings into next-test runbooks and import-ready campaign assets.

Strategic line

A portable creative intelligence layer for AI-generated advertising.

One-liner (homepage / Twitter / hero)

Capture what you tested. Understand what worked. Generate what to try next.

Killer wedge

Ad platforms are getting better at generating creative, but worse at helping you own the learning. Creative Patterns solves that.

1. Why This Exists

The shift in paid growth

Reddit, Meta, Google, TikTok, and LinkedIn are all moving toward more AI-assisted campaign creation:

• generated headlines and descriptions
• auto-resized creative
• AI image and video variations
• dynamic combinations
• performance-driven recommendations
• black-box creative optimization

This shifts the bottleneck for founders, SMEs, and growth teams from:

"Can I generate more ad variants?"

to:

"Can I understand what the platform generated, what worked, what patterns are emerging, and what I should intentionally test next?"

The pain

The platform CSV gives you performance metrics, but not the creative intelligence you actually need:

• headline text, image, CTA, landing URL
• audience / subreddit / placement context
• creative structure, visual style
• why an ad worked

The CSV tells you what happened. It does not tell you why, and it does not tell you what to make next.

The platform is incentivized to keep that loop inside its own black box. Creative Patterns gives the user their own loop.

The whitespace

There are many tools around the edges:

• creative analytics platforms (too enterprise)
• ad reporting dashboards (too analytics-heavy)
• AI ad generators (spammy, generic, no memory)
• DAM / brand management tools (too heavy)
• spreadsheet reporting (too manual)

Almost nobody gives small teams a clean operating system for:

what we tested, what worked, why it worked, and what we should generate next.

That is the whitespace. That is Creative Patterns.

2. Positioning

Category

Creative intelligence notebooks for paid growth.

Three words people already understand:

• Creative — ads, hooks, assets, messaging
• Intelligence — patterns, learnings, recommendations
• Notebooks — lightweight, portable, editable, AI-friendly

Positioning statement

For founders, SMEs, and growth teams running paid experiments, Creative Patterns is a Markdown-native workspace that captures the creatives ad platforms generate, connects them to performance, and turns the learnings into reusable patterns and import-ready next tests — outside the platform's black box.

Not vs. Is

The product thesis

AI ad platforms are making it easier to generate ads, but harder to understand creative learning. Creative Patterns gives founders and growth teams a portable notebook for capturing, analyzing, and reusing the patterns behind paid growth.

3. Audience

Primary users (V1)

Small but serious paid experimenters:

• Indie hackers and bootstrapped founders running their own ads
• SaaS founders testing paid acquisition
• Solo growth marketers and performance marketers
• Small B2B SaaS marketing teams
• AI-tool, Chrome-extension, and developer-product founders
• Small agencies and growth operators
• Newsletter / sponsorship test operators

Initial wedge

Founders running Reddit Ads.

Why Reddit first:

• Reddit Ads reporting is thin
• Audiences are niche-driven, so creative-market fit matters heavily
• Tooling is immature compared to Meta/Google
• Small teams are actively experimenting there
• We are the first user (PageStash runs Reddit Ads)

Expansion path

Reddit → Meta → Google Display → LinkedIn → X → TikTok → newsletter sponsorships → landing page tests → organic post performance.

The product is not "Reddit Ads Analytics." It is "Creative intelligence for paid growth, starting with Reddit Ads."

Jobs to be done

When a user opens Creative Patterns, they are hiring it to:

1. Remember what they tested across campaigns and platforms.
2. Explain which creatives worked and why, in plain language.
3. Decide what to test next, with confidence not vibes.
4. Generate the next batch of variants in a format they can hand to ChatGPT, Claude, Midjourney, Figma, Canva, or paste back into the ad platform.
5. Own their creative memory — portable Markdown, CSV, and assets — independent of any single platform.

4. The Validation Loop

The entire product is built around one loop. Every screen, button, and command should serve it.

Capture → Import → Enrich → Find Patterns → Generate Runbook → Export

Capture

Chrome extension grabs creative context from inside Reddit Ads Manager: ad name, headline, body, CTA, image, preview screenshot, campaign / ad group context, landing URL.

Import

User uploads the platform's CSV export (Reddit first). The product parses, normalizes, and prepares to merge.

Enrich

CSV performance rows are matched to captured creatives by Campaign + Ad Group + Ad Name. The user can manually fill in anything missing (creative concept, persona, hook, audience notes).

Find Patterns

The pattern engine groups ads by creative attributes, calculates weighted performance, applies confidence thresholds, and surfaces ranked patterns with evidence.

Generate Runbook

A runbook is a Markdown execution plan — a context-rich prompt the user can hand to ChatGPT / Claude / Cursor, or use to brief a designer.

Export

Markdown notebooks, platform-ready CSVs, asset prompt packs, and creative briefs — all owned by the user.

The success moment

The user uploads a Reddit Ads export and leaves with new ad concepts, asset prompts, and a CSV-ready batch of variants they can put straight back into Reddit Ads.

If we deliver that in under 10 minutes for a first-time user, we win.

5. Product Architecture

Core components

1. Chrome Extension          → captures creative + context from ad platforms
2. Web App (Workspace)       → notebook editor, ads table, patterns, runbooks
3. Markdown Notebook System  → portable, AI-native source of truth
4. Pattern Engine            → statistics + tagging + AI narrative
5. Export Generator          → Markdown, CSVs, prompt packs, briefs
6. Integrations layer        → HTTP API + MCP so the same workspace is a component in external pipelines

Data flow

Reddit Ads Manager (or other platform)
        ↓
Chrome Extension captures creative + context
        ↓
Creative Patterns workspace
        ↓
CSV report import merges performance metrics
        ↓
Pattern engine analyzes creative attributes vs. performance
        ↓
Runbooks and import-ready assets generated
        ↓
User exports Markdown / CSV / prompt packs
        ↓
User feeds runbooks into ChatGPT / Claude / Midjourney / Figma / ad platform
        ↓
New tests run → loop repeats → notebook gets smarter

The extension creates the proprietary dataset. The CSV gives the performance data. The notebook gives the brand and GTM memory. The pattern engine turns it into recommendations. The runbooks turn intelligence into execution.

Live intelligence pipeline (GTM snapshot)

What ships today, in one place, for homepage and outbound copy:

• Find Patterns runs the full engine on demand: weighted lift vs campaign baseline, confidence gates, mechanical cross-checks, and narratives that may only restate engine-calculated evidence (no invented metrics).
• Pattern Intelligence uses cluster-aware card titles — e.g. bundling multiple winning facets that share the same ads into a single creative-family headline, readability-at-scale labels when sample depth supports them, segment- and TF-IDF-style phrasing, and overlap hints when the same ads sit under several tags. The same presentation layer feeds runbook Markdown (winner lists, narratives, cluster headings, execution “strongest signals”), so what marketers read in the app matches what lands in ChatGPT/Claude briefs.
• Progressive analysis UX streams phased status during a run so operators see enrichment → detection → narratives instead of a silent spinner.
• Notebook sync maintains canonical Winning-Patterns.md / Underperforming-Patterns.md excerpts after a successful run. Every runbook generation performs a fresh pattern analysis for that campaign and merges engine output plus brand/GTM excerpts — runbooks are not tied to a stale snapshot from an earlier tab visit.

The workspace model (file system)

creative-patterns/
├── brand/
│   ├── Brand Guidelines.md
│   ├── Voice and Tone.md
│   └── DESIGN.md
├── gtm/
│   ├── Audience.md
│   ├── Positioning.md
│   ├── Offers.md
│   └── Objections.md
└── campaigns/
    └── reddit-2026-04-pagestash-test/
        ├── Campaign Brief.md
        ├── Imported Report.csv
        ├── Creative Inventory.md
        ├── Performance Learnings.md
        ├── Pattern Analysis.md
        ├── Next Tests.md
        ├── ChatGPT Runbook.md
        ├── Claude Runbook.md
        ├── Reddit Import.csv
        └── assets/
            ├── AG1_AD1_Permanent_Archive.png
            └── AG1_AD2_Save_Any_Page.png

Markdown matters because it makes the product portable, AI-native, easy to edit, easy to copy into any LLM, easy to version, and far less intimidating than another SaaS dashboard.

Programmatic access & integrations

Many users will not stop at the browser: they want workspaces, patterns, and runbooks addressable from code — internal brief tools, agency automation, scheduled exports, or vibe-coded ad ops apps. That should be a first-class product surface, not an afterthought.

• HTTP API (workspace-scoped): Authenticated requests to list campaigns and ads, read pattern outputs, fetch notebook Markdown by path, trigger exports or runbook generation where billing and credits allow, and optionally retrieve a full workspace snapshot in one job-oriented call. Long-running work uses idempotent jobs + polling or webhooks.
• Workspace API keys: Self-serve create / label / revoke in the app; secrets are cp_sk_… shown once and stored as SHA-256 only. V1 exposes read-only notebook access over HTTP; scopes, per-key rate limits, audits, and creative-credit debits on write/trigger routes follow. Bearer verification uses the Supabase service role on the server (never in the browser).
• MCP (Model Context Protocol): A documented MCP server so Cursor, Claude Desktop, and other hosts can pull live pattern summaries and notebook context into agents without manual copy-paste — same authorization model as the HTTP API, different wire format for LLM-native workflows.

The web app exposes an Integrations entry (global workspace chrome) as the home for keys, docs, and MCP install instructions. Technical requirements and acceptance criteria live in docs/Prd.md §5.6.

6. The Pattern Engine (the brain)

The pattern engine is the part of the product that earns trust. It must avoid two failure modes:

1. Vague AI bullshit ("Try shorter copy!")
2. Fake precision (declaring winners on 80 impressions)

So we ground every finding in an algorithmic backbone, then let AI add narrative on top.

Five layers

Layer 1 — Basic performance metrics CTR, CPC, CPM/eCPM, spend, click volume, impression volume, lift vs. campaign average, lift vs. ad group average.

Layer 2 — Statistical guardrails (confidence) Minimum thresholds before any pattern is labeled a winner.

Layer 3 — Creative attribute tagging Every ad is tagged on a structured schema (AI-assisted, user-editable):

hook_type        e.g. contrast, pain_point, fear_of_loss, utility
persona          e.g. osint_researcher, journalist, founder
promise          e.g. permanent_archive, faster_workflow
visual_style     e.g. dark_product_ui, abstract, screenshot
specificity      low | medium | high
urgency          low | medium | high
proof_type       e.g. testimonial, screenshot, stat
cta_style        e.g. try_free, learn_more, save_page
format           e.g. single_image, carousel, video

Layer 4 — Pattern comparison Group ads by tag combinations, compare weighted performance vs. campaign baseline.

Tag: promise = permanent_archive Ads: 3 · Weighted CTR: 0.56% · Campaign avg: 0.419% Lift: +34% · Confidence: medium

Use weighted averages (total clicks / total impressions), never simple averages, so tiny ads can't distort results.

Layer 5 — AI narrative Once the math is done, AI translates findings into useful language. AI never invents numbers — it only narrates calculated metrics.

Pattern output format (always the same five fields)

Pattern         — what we observed
Evidence        — the math, with raw numbers
Confidence      — high / medium / low, with rationale
Recommendation  — what to do about it
Next Test       — concrete generation brief

This format is the contract that makes the product feel trustworthy.

Useful V1 algorithms

• Lift calculation — pattern_ctr / campaign_ctr - 1 and campaign_cpc / pattern_cpc - 1
• Minimum sample thresholds — never label winners below them
• Pattern score — weighted combination of CTR lift, CPC efficiency, sample size, consistency across ad groups
• Loser detection — flag underperformers so the user knows what to stop doing
• Next-test recommendation logic:
  • winning hook → variant generation
  • winning persona → deeper persona variants
  • high CTR / high CPC → improve targeting or LP
  • low CTR / low CPC → improve creative
  • high impressions / low clicks → headline problem

Build language: TypeScript first, Python later

V1 is calculable in TypeScript (Next.js / Node):

• CTR/CPC math, lift, weighted averages
• tag grouping, confidence scoring
• CSV parsing (PapaParse), simple scoring

V2 may add a Python worker for richer analysis: clustering, embeddings, similarity, Bayesian testing, multi-armed bandit. Architect the engine cleanly so this is a swap, not a rewrite.

7. Runbooks (the killer feature)

Most tools stop at insight. Creative Patterns goes one step further:

Insight → runbook → assets → import-ready campaign.

A runbook is a Markdown execution plan: a context-rich, copy-pastable brief for ChatGPT / Claude / Cursor / a designer / the ad platform itself.

Patterns and runbooks move together. Generating a runbook re-runs the same server-side pattern pass used in the Patterns tab, then composes Markdown from that output plus notebook context (Brand, Positioning, Design, saved pattern excerpts, winning-cluster ad copy). When the engine or card-copy logic improves, the next runbook pick-up is automatic — no separate “sync runbook templates” step.

Every runbook contains

Context · Brand Memory · Inputs · Goal · Winning Patterns ·
Constraints · Instructions · Output Format · Platform Notes

Default runbooks (V1)

1. Generate New Reddit Ads From Winning Patterns
2. Turn Winning Hook Into Meta Ad Variants
3. Create Image Generation Prompts From Creative Learnings
4. Create Platform Import CSV
5. Generate Landing Page Message Tests
6. Summarize Campaign Learnings for Future Tests

Why this is a moat

Runbooks are reusable Markdown templates. Every campaign generates new ones. Every runbook can be improved over time. It makes the product extensible without complex engineering — and shippable as content (e.g., a public runbook gallery later).

8. Brand & Design Direction

Personality

Premium · minimal · slightly technical · quietly powerful · founder-friendly · designer-friendly. Not enterprise-heavy. Not hypey.

Visual direction

• Dark mode first
• Soft graphite background
• Off-white typography
• Muted violet or electric blue accent
• File tree navigation
• Markdown editor feel
• Clean cards, subtle borders, rounded corners
• Minimal charts (numbers and lift over visualizations)
• Command palette (⌘K)
• Tasteful, restrained motion

Design system file: DESIGN.md (Stitch)

Brand-facing tokens + intent live in Brand/DESIGN.md, following Google's open DESIGN.md format from Stitch: YAML front matter for machine-readable design tokens (colors, type, radii, spacing) and Markdown body for semantic rules, accessibility, and motion — so humans, the pattern engine, and coding agents share one contract. This replaces a loose "Visual System" checklist with a portable, version-controlled standard aligned with the wider AI-design-tooling ecosystem.

Product feel reference set

• Cursor — for creative testing
• Linear — for campaign execution
• Raycast — for commands
• Notion — for the notebook feel (lighter)
• Vercel dashboard — for restraint and polish
• Superhuman — for keyboard speed

Avoid

Big rainbow dashboards · growth-hack aesthetics · cartoon mascots · AI sparkle overload · enterprise reporting clutter · loud SaaS gradients · vague "Powered by AI ✨" badges.

Vocabulary

Use:

Workspace · Notebook · Pattern · Learning · Next Test · Runbook · Asset Brief · Import File · Creative Memory · Capture · Enrich

Avoid:

Attribution Modeling · Multi-Touch Analytics · Regression Analysis · Media Mix · Cohort Intelligence · Enterprise Governance

Messaging

9. Pricing & Monetization

Pricing should map to value created (creatives understood) not seats. The user should think:

"This is cheap enough to use every time I run a campaign."

Unit of value

Ads analyzed (1 ad = 1 credit). Internally, we describe this as "creative combinations analyzed" because as platforms generate more variants — headline × body × image × CTA × audience × placement — the unit naturally scales.

Plans

Credit accounting (internal, mostly hidden from user)

Analyze single ad           1 credit
Generate next-test runbook  10 credits
Generate 10 ad variants     10 credits
Generate image prompt pack  10 credits
Generate platform CSV       5 credits

A typical 25-ad campaign loop = ~50 credits. So Starter ≈ 5 full campaign loops/month.

Early access (validation lever)

Founder Plan — $49 lifetime · first 100 users.

1,000 ads analyzed/month for 12 months · Reddit workflow · Markdown notebooks · AI runbooks · platform-ready exports.

This is the validation mechanism. Ten paid early users justify deeper investment.

10. Tech Stack (V1)

Familiar, fast, and boring on purpose. Full reasoning per choice in docs/Decisions.md.

11. Roadmap (5 weeks to private beta)

Week 1 — Workspace + CSV import

Workspace creation, Markdown notebook editor, CSV upload + parser, ads table, manual enrichment.

Week 2 — Chrome extension capture

Extension shell, Reddit Ads page detection, capture current ad fields, capture preview screenshot, sync to workspace.

Week 3 — Merge + pattern engine

Match CSV rows to captured ads, tag creative attributes, calculate pattern performance, generate confidence-scored findings.

Week 4 — Runbooks + exports

ChatGPT runbook, Claude runbook, asset prompts, Reddit import CSV, next-tests.md, performance-learnings.md.

Week 5 — Polish + private beta

Premium UI pass, sample workspace, onboarding, pricing page, early-access checkout, $49 lifetime founder offer live.

What V1 deliberately excludes

OAuth · ad platform APIs · multi-user permissions · real-time dashboards · advanced attribution · complex charts · team collaboration · built-in image generation · billing complexity beyond Stripe.

12. Validation Plan

Step 1 — Dogfood on PageStash

Import the existing PageStash Reddit Ads report. Manually enrich the 12 ads. Generate Performance Learnings, Next Tests, ChatGPT Runbook, Reddit Import CSV, Asset Prompts. Use those outputs to launch the next batch of PageStash ads.

Success metrics:

• CTR moves from ~0.419% toward 0.7%+
• CPC drops below $0.77
• Time to create the next ad batch drops by 50%+

Step 2 — Recruit 13 design partners

• 5 founders running Reddit Ads
• 5 founders running Meta Ads
• 3 agency / growth operators

Pitch: "I built a tiny Markdown workspace that turns Reddit Ads exports into better next tests."

Step 3 — Charge early

Ship the $49 lifetime founder plan. Validation target: 10 paid early users. That's enough signal to justify the next 90 days of build.

13. The Real Moat

The CSV parser is not the moat. The pattern engine is not the moat. Even the Chrome extension is not the moat.

The moat is accumulated creative memory.

Over time, the workspace knows:

• which hooks worked
• which claims worked
• which audiences responded
• which visuals failed
• which CTAs improved clicks
• which platform formats fit the brand
• which generated ads were actually launched
• which tests became winners

That becomes a reusable growth memory layer — portable Markdown the user owns, that compounds in value with every campaign, and that gets more valuable as ad platforms generate more black-box AI variants.

This is why the Markdown notebook model is so strong: it is the substrate of memory.

14. Strategic Risks & Mitigations

15. Naming, Identity, Surface

• Product name: Creative Patterns
• Workspace artifact: a notebook
• Wordmark icon: the existing creative-patterns-icon-mark.svg
• Domain: https://creativepatterns.app (production)
• GitHub org / repo: creative-patterns/app, creative-patterns/extension, creative-patterns/runbooks
• Twitter / X: @creativepatterns

16. Final Product Statement

Use this as the north star for every PR description, every landing page revision, every investor email, every Tweet:

Creative Patterns is a simple Markdown workspace and Chrome extension that captures paid ad creatives, connects them to performance, and turns the learnings into next-test runbooks and import-ready campaign assets.

A portable creative intelligence layer for AI-era paid growth.

Validation loop: Capture → Import → Enrich → Find Patterns → Generate Runbook → Export

First killer workflow: Upload Reddit Ads CSV → enrich captured creatives → identify winning patterns → generate new ad variants → export assets and a CSV-ready campaign.

That is the blueprint. Now we build.