21
External Connectors
16
Skills / Automations
7
Cross-Projects
7
Detailed Case Studies
01

The Four-Layer System

Every Claude Code "work OS" runs on the same stack. Configure these four layers and the system works for any domain.

📚

Layer 1: Project Brain

CLAUDE.md
A single markdown file in your project root. Claude reads it at the start of every conversation. It contains everything Claude needs to act as your teammate: who you are, what you're building, who the team is, the rules, the guardrails.
What a mature CLAUDE.md includes (15KB+) Team roster with roles · Confidentiality guardrails · Brand design tokens (fonts, colors, spacing) · Competitive context (key competitors, positioning) · Content guardrails (preferred terminology, tone rules) · Active workstreams · Campaign folders · Cross-project references · Creative production patterns
💡

Layer 2: Persistent Memory

Auto-memory + Supermemory knowledge graph
Two layers of memory. Auto-memory (built-in) saves corrections and context as local markdown files. Supermemory (API layer) stores documents in a searchable knowledge graph, accessible via semantic search from any skill.
Example memories Claude has saved "Never comment on my schedule" · "Save transcripts with date prefix in subfolder" · "Use 'team members' not 'resources' for people" · "Vendor call part 2 is confidential" · "Project tracker sheet at this URL"
⚡

Layer 3: Repeatable Workflows

Skills (slash commands)
A skill is a markdown instruction file that tells Claude exactly how to run a multi-step process. You type /skill-name and it executes the whole workflow. Like macros, but they can make decisions, call APIs, search memory, and handle edge cases.
Project-scoped skills /ghostwrite · /daily-log · /daily-briefing · /brain-dump · /save-meeting · /call-prep · /competitive-intel · /leadership-update · /content-ideas
🔗

Layer 4: External Connectors

MCP Servers + CLI tools
MCP (Model Context Protocol) servers let Claude talk to external services – Slack, meetings, design tools. CLI tools handle Gmail, Drive, Calendar, Sheets. Skills orchestrate these connectors into automated workflows.
Example connectors Granola (meeting transcripts) · Slack · Figma · context7 (library docs) · Supermemory (knowledge graph) · Gmail/Drive/Calendar/Sheets via CLI · Chrome · whisper.cpp (transcription)
📊

The Glue: Git as Audit Trail

Every artifact is version-controlled and pushed
This isn't a code project, but I use Git anyway. Every daily log, meeting transcript, strategy doc, and campaign creative gets committed and pushed. Full history of what was produced, when, and why. The /daily-log skill auto-commits and pushes at the end of each run.
02

External Connectors

The bridges between Claude and the outside world. MCP servers, CLI tools, and direct APIs – grouped by purpose. Skills orchestrate these; the workspace holds what flows through them.

Comms & collaboration
🎤
Granola (MCP)

Meeting transcripts, summaries, attendees

💬
Slack (MCP)

Channel search, DMs, drafts

📅
Google Workspace CLI

Calendar, Gmail, Drive, Sheets, GDoc handoff

📜
Tally (MCP)

Form-builder schema + submissions

Marketing & performance data
📈
Meta Marketing API

Read: campaign spend, installs, creative-level performance · Write: video uploads, paused-draft campaign creation

📊
Google Analytics (MCP)

GA4 property reports, realtime, custom dimensions

🔍
Search Console (MCP)

Organic queries, page performance, indexing health

🎯
Mixpanel (MCP)

Product analytics – funnels, retention, event-level cohorts

📲
AppsFlyer (API)

Mobile install attribution – acquisition + retargeting cohorts joined to ad-level spend

Design, ingestion & automation
🎨
Figma (MCP)

Read: design context, screenshots, code-connect · Write: HTML-to-Figma capture – renders a served HTML page directly into a real Figma file (frames, text layers, image fills, vector paths)

🎬
Higgsfield (MCP)

AI image + short-form video generation for ad assets and brand visuals

🗣
HeyGen (MCP)

AI avatar / presenter video generation for talking-head and announcement clips

🎙
whisper.cpp

Local audio transcription (GPU-accelerated)

🎧
Speaker Diarization

Secondary machine for CPU-bound pyannote workloads

🌐
Chrome / Playwright (MCP)

Browser automation, screenshots, competitive scrapes

Memory & AI reasoning
🧠
Supermemory (SDK)

Persistent knowledge graph – semantic search across every synced doc

🤖
Codex / Gemini (MCP)

Second-opinion passes + long-context research via alternate models

🔭
Parallel (API/MCP)

Live web search + fetch – real-time research and source retrieval

Dev infrastructure
💻
GitHub

Version control, auto-push, audit trail

▲
Vercel

Internal tool deployment, env management

🔥
Firebase

Auth + Firestore for internal tools

How skills and pipelines compose connectors /call-prep reads from Granola + Slack + Supermemory · /competitive-intel chains a Parallel web sweep + Playwright scrape → whisper.cpp transcribe → Supermemory index · /daily-log pushes to GitHub + triggers Supermemory sync · A performance-marketing review can pull Meta spend + AppsFlyer install cohorts + Mixpanel funnels + GA conversions + Search Console rankings into a single brief without leaving the terminal · Write-side composition: Higgsfield renders short-form video assets (or HeyGen for avatar-led cuts) → the assets land in a manifest → the Meta Marketing API write pipeline (Section 07) turns the manifest into a paused draft campaign without ever leaving the shell.

Design-write composition: drafted-in-HTML feature concepts at native mobile width → local HTTP server + capture-script tag → Figma MCP captures the rendered DOM into a real Figma file (Section 10), where a designer adds craft tweaks or devs build straight from the captured frames.
03

Workspace Structure

One folder = one project. Organized by work stream, not file type. Flat rather than nested. Claude reads this directly as context – the filesystem itself is part of the interface.

📁

What the project root looks like

One canonical layout, generalizable across domains
Your Project/
├── .claude/skills + settings + permissions
│   ├── skills/project-scoped skill definitions
│   └── settings.local.jsonallowed tools, permissions
├── CLAUDE.mdthe project brain – auto-loaded every session
├── Daily Log/one structured markdown per day
├── Daily Briefing/morning briefing outputs
├── Brain Dump/silent capture, routed at EOD
├── Meeting Transcripts/date-prefixed, summaries + transcripts
├── Call Prep/pre-meeting briefs
├── Leadership Updates/recurring stakeholder briefs
├── Research/foundational strategy + market docs
├── Brand/logos, fonts, tokens, guidelines
├── Competitive Intel/scraped data + analysis per competitor
├── {Campaign A}/one folder per initiative (see right)
├── {Campaign B}/
├── Scratch Pad/ad-hoc thinking, triaged periodically
├── .local/PII + secrets – gitignored, sync-skipped
├── sync-to-supermemory.tsknowledge graph sync script
├── search-supermemory.tssemantic search script
├── .supermemory-sync.jsonchange-detection tracker
├── .supermemory-skipper-file sync exclusions
├── strategy-doc.mdroot-level .md = always in grep range
└── research-report.md
Inside a typical campaign folder
{Campaign A}/
├── brief.mdthe campaign thesis + guardrails
├── creative-direction.md
├── scripts/video scripts, voiceover copy
├── creatives/HTML mockups, exported PDFs, PNGs
├── data.csvcomparison tables, asset lists
├── render.pyone-off script lives with the work it serves
└── post-mortem.md
🎯

Why this shape

Six design choices, each a deliberate trade-off
  1. One folder per project, everything inside it. Strategy, research, meeting notes, creatives, scripts, CSVs – all in one tree. No split repos, no "docs here, assets there". Cross-project work gets a separate top-level folder, not a shared sub-directory.
  2. Folders by work stream, not by file type. A campaign folder holds its markdown, scripts, CSVs, and creatives side-by-side. File-type folders (scripts/ at root, docs/ at root) get stale the moment a project grows.
  3. Flat rather than nested. Claude navigates via Read and Grep. Two levels deep is usually enough. Deep nesting adds friction without payoff – grep doesn't care.
  4. Root-level .md for always-in-range docs. Strategy docs at the root get hit by default greps and appear first when Claude scans for context. Use root placement as a hint that something is primary.
  5. .local/ for PII and secrets. Gitignored. Listed in .supermemory-skip so it never syncs to the knowledge graph. The only safe place for raw exports, CV dumps, financials.
  6. One-off scripts live with the work they serve. A render script for a single campaign stays inside that campaign's folder. A central scripts/ directory becomes a graveyard. If a script graduates to multi-use, it moves to root – not before.
03.5

Two Brains: The One You Write, The One Claude Writes

There are two kinds of memory. The project brain you write by hand (a CLAUDE.md that loads every session) and the auto-memory Claude keeps for itself (small files it indexes, cross-references, and grows over time). Correct Claude once and it remembers for good.

The brain you write you author this
🧠 CLAUDE.md Auto-loaded every session
##
Who I Am
Role, mandate, reporting line
##
My Remit
What this person owns
##
About the Company
Stage, model, scale, vision
##
Brand Pillars
Core positioning principles
##
Key People
Team roster with roles
##
How to Help Me
Default behaviour and tone
##
Confidentiality Rules
What never leaves the room
##
Content Guardrails
Terminology and framing limits
##
Design Rules
Brand tokens, fonts, colours
##
Active Workstreams
Live to-dos, auto-refreshed
Why it works One plain Markdown file, written in plain words, sitting in the project folder. Claude reads the whole thing at the start of every session. So everything Claude needs to act like a real teammate is in one place you can scan. Update a rule here and the next session already knows it. No setup screen, no settings panel. You just write what you would tell a new hire.
The brain Claude writes Claude authors this
user Your role, skills, preferences
feedback Corrections, "don't do X"
project Deadlines, decisions, context
reference Links to external systems
MEMORY.md – the index
- [Terminology rule](feedback_terminology.md) – use "team members", not "resources".
- [Project tracker](reference_tracker_sheet.md) – live status sheet for the initiative.
- [Schedule rule](feedback_no_schedule.md) – never comment on the user's hours.
One memory file – anatomy
---
name: terminology-rule
description: how to refer to people
metadata.type: feedback
---
Why: the user corrected this once and wants it permanent.
How to apply: in every draft, swap "resources" for "team members".
Related: [[feedback_tone_rules]]
Memories cross-reference into a graph [[tone]] [[terms]] [[tracker]] [[schedule]] [[brief]] feedback_tone feedback_terms project_brief reference_tracker feedback_hours

Each memory file points at the others with [[wikilinks]], so loading one pulls in the related rules. The memories form a graph, not a flat list. Over weeks this turns into a mature, fully-indexed, cross-referenced web that compounds with every session.

🔄

The Learning Loop

How Claude gets smarter on its own, without you configuring anything
💬
You correct Claude

"Use 'team members', not 'resources', when you talk about people on the team."

💾
Claude writes a feedback memory

It saves a small file with the rule, the reason it matters, and when to apply it.

🔗
You point at an outside resource

"The project tracking sheet lives at this Google Sheet link."

💾
Claude writes a reference memory

It notes where to look the next time that topic comes up.

🌅
Next session starts

Claude reads the MEMORY.md index and loads the memories that matter. No prompting needed. It already knows your preferences and your context.

🚀
It compounds over time

Every session adds a little more. After a week, Claude knows your team, your rules, your tools, and your style. You never wrote a line of config.

03.7

Going Further: Long-Term Memory Graph

The auto-memory system works per-project. To build a persistent, searchable knowledge graph across everything, I integrated Supermemory via SDK.

🧠

Supermemory Knowledge Graph

Dozens of documents synced, semantic search integrated into skills
Claude Code's built-in auto-memory saves corrections and context as local markdown files. This works great for one project, but I wanted all my accumulated knowledge – meeting transcripts, strategy docs, research, daily logs – queryable from any skill. So I built a sync pipeline (sync-to-supermemory.ts) and a search script (search-supermemory.ts) using Supermemory's free-tier SDK. Semantic search is now integrated into /ghostwrite, /call-prep, and /competitive-intel.
Local Auto-Memory (built-in)
  • Markdown files in ~/.claude/
  • Feedback, preferences, references
  • Per-project scope
  • Claude reads MEMORY.md index each session
  • Great for corrections and rules
Supermemory Graph (SDK layer)
  • Cloud-hosted vector store via free-tier SDK
  • Dozens of documents ingested with categories and metadata
  • Cross-skill, cross-session scope
  • Skills query via search-supermemory.ts
  • Great for deep context and knowledge retrieval
/daily-log triggers sync
→ sync-to-supermemory.ts runs
→ Docs categorized in vector store
→ Skills query via search-supermemory.ts
What's in the graph Brand strategy docs · Research reports · Meeting transcripts · Daily logs · Campaign playbooks · Call prep notes · Content strategy research · Agency scope docs · Competitive intel · Media summaries – all categorized and retrievable via semantic search
04

Skill Workflows in Detail

Nine skills, each a markdown file that orchestrates tools, makes decisions, searches memory, and handles edge cases. One command, full automation. Project-scoped skills live in .claude/skills/; global skills live in ~/.claude/skills/.

/daily-briefing Pull → Synthesize → Prioritize pattern

An opinionated start-of-day read in 30 seconds. It pulls the calendar, yesterday's unfinished items, and overnight messages, then ends by naming the top three things to focus on. It tells you what matters instead of listing everything. It runs unattended each morning and saves itself.

Today's calendar, prep-aware

Pulls meetings and attendees. For each one it checks whether a prep doc already exists and links it, or offers to make one. A scheduled meeting with no prep is a visible gap, not a surprise.

Calendar CLI Read
Yesterday's loose ends

Unfinished to-dos from the latest log carry forward. Anything still open across two logs is flagged "open 2+ days" so slow leaks get caught.

Read
Catch everything aimed at you

Rather than a fixed channel list, it searches every mention and direct message across all of Slack, plus a few key colleagues even when you are not tagged. It then opens the threads under those hits, because a single ping often hides a multi-day back-and-forth. Last few emails are read regardless of read status.

Slack Gmail CLI
Tuesday only: a tiny competitor pulse

On the morning after the weekly competitor scan runs, it lifts at most three genuinely-new lines from that file. Every other day it stays silent rather than re-summarising old news.

Read
Not Tuesday? Skip the competitor section entirely.
Name the top three, then save

Picks three priorities by urgency, leverage, and what is blocked, not a list of eight. Saved to the desktop and the project archive in one pass.

Claude reasoning
/save-meeting Ingest pattern Project

Pull → Filter → Transform → Save. Turns a Granola meeting into a clean, fixed-shape document in the project. It diffs against a tracker so it only ever saves what is new, catches up on anything missed before, and can run fully unattended.

List recent meetings from Granola

Calls Granola's REST API, an authenticated web endpoint, with a bearer token to list recent notes, newest first. Older ones are pulled page by page when needed.

Granola REST API
Filter, then diff against a tracker

Keeps only work-relevant meetings, then checks each against a tracker of what is already saved. It walks newest-first and stops at the first one already recorded, building a small catch-up list of only the new ones.

Claude reasoning
All already tracked? Report "tracker is current" and stop. Otherwise queue the new ones, capped at five.
Pull full content, with a fallback

One call returns metadata, summary, and the verbatim transcript. If a meeting just ended and is not on the server yet, it reads the live transcript from Granola's local desktop cache instead.

Granola REST API Desktop cache
Transform into a fixed structure

Speaker labels get real names, social chit-chat is trimmed, and the meeting is reshaped into one consistent skeleton:

1. Details header – date, attendees, source 2. Summary by topic – one heading per topic, bullets that keep the names, numbers, and quotes that matter 3. Action items – next steps with owners 4. Cleaned transcript – real names, no filler
Write
Record each save as it lands

The tracker is updated per meeting, inside the loop. So a failure halfway through never causes already-saved meetings to be re-fetched on the next run.

Memory tracker
/call-prep Research pattern Project

A short brief before a meeting so you walk in knowing the history. It pulls every prior mention of the person and topic from across the workspace, then writes a one-page doc that leads with what is still open between you and what to actually raise.

Read the ask

Who is the call with, and what is it about? If the topic is left out, it is inferred from recent activity with that person.

Claude reasoning
Search by meaning first

Start with Supermemory, the project's searchable memory store. It finds the right transcript even when the meeting never used your exact keyword.

Supermemory search
Then fill gaps by keyword

Grep the project instructions, past transcripts, and recent daily logs for exact names, dates, and the last interaction. One confidentiality rule is hard-wired: certain sensitive call notes are never surfaced.

Grep Read
Write the brief, value-first

Open items lead, not background. Then talking points, what to ask, and watch-outs like political dynamics. First-time call with no history? It flags what you do not know yet rather than faking it.

Claude reasoning Write
Show it, then file it

Shown inline so you can tweak before the call, then saved with a date prefix for next time.

/brain-dump Capture pattern Project

A no-friction place to park raw thoughts so nothing is lost. It runs in two modes off one trigger. Say it with a thought and the thought is saved word-for-word. Say it bare, mid-session, and instead it writes a full snapshot of the conversation so you can safely wipe the context and keep going. The payoff lands later: at end of day /daily-log reads this file and files every entry under the right heading, in your words.

Pick the mode from the message

Thought attached means save-it mode. Trigger word alone means snapshot mode. When unsure, snapshot and say what was saved.

Claude reasoning
Content after the trigger? Save verbatim. Trigger alone? Write a session snapshot.
One file per day, append-only

If today's file exists, add to it. If not, start it with a date header. Old entries are never touched.

Glob
File exists? Append. New day? Create from a date header.
Save-it mode: keep the voice intact

Fix only typos and stray punctuation. Tone, slang, lowercase, phrasing all stay. Never rephrase or reorganise. Each entry gets a clock-time header so the day reads as a stream.

Edit
Snapshot mode: a safe-to-clear record

Walk the conversation and capture files touched, findings, decisions, open items, and stated preferences. Point to artifacts already on disk rather than copying them. Ends with an explicit "you can clear context now" line.

Claude reasoning
One line back, then silence

Just a save confirmation. No echo of the content, no follow-up questions. Staying out of the way is the whole point.

/competitive-intel Intelligence pattern

A competitor scan that combines what you already knew with what just broke in the press. It reads internal files, searches the memory store, then sweeps the web, and grades every outside claim by how trustworthy the source is before it lets that claim shape the read. It runs itself once a week, unattended, and saves to two places.

Read the existing picture

Search the memory store, then grep the project's intel files, recent logs, and transcripts. Compile last-known metrics and recent moves so the web sweep only has to find what changed.

Supermemory search Grep
Sweep the web in priority order

Parallel, a search tool built for agents, runs first for clean citations. Native search cross-checks anything big. A third search tool breaks ties when two sources disagree on a number.

Parallel search WebSearch
Grade every claim by source tier

Each finding is tagged trustworthy, medium, or weak. Only the top two tiers are allowed to drive the "what this means" section. The same funding event reported by four outlets is collapsed into one, so coverage volume is not mistaken for confirmation.

Claude reasoning
Claim only in a weak-tier source? Note it, but never build the analysis on it.
Synthesise into a decision brief

What we knew, what is new, what it means for us, and what to watch. Internal only, with sensitive call intel walled off.

Claude reasoning
Save twice, refresh the canon

A plainly-named copy on the desktop is the at-a-glance proof the weekly run fired. A date-stamped copy in the project builds the archive. If something material moved, the rolling source-of-truth file is updated too.

Write
/leadership-update Gather → Select → Draft pattern

The recurring brief to the founder and a key stakeholder, sent roughly every two weeks. It is a leadership brief, not a status report, so it gathers two-plus weeks of activity, lets you choose what makes the cut before any drafting, and makes every decision-needed an explicit ask.

Gather the whole window

Reads two-plus weeks of daily logs, new transcripts, and the relevant group chat, then checks the last update so nothing is repeated and any earlier promise gets a follow-up line.

File read Slack
You choose before it drafts

It presents a numbered menu of everything update-worthy and waits. You pick which topics make it and at what depth. It never writes the full update on its own first guess.

Claude reasoning
No drafting until you have picked the topics and the detail level.
Draft for a busy reader

Each section leads with what happened, links docs inline so nobody has to go hunting, and turns any decision into a direct question. Capped at six to eight sections so it stays a brief.

Claude reasoning
Save plus a paste-ready copy

Markdown is archived. A rich-text copy lands on the desktop so it pastes cleanly into email or Slack with formatting and links intact.

File write
/ghostwrite Content creation Project

LinkedIn drafting for any author at the company: the brand page by default, the founder, or a colleague. The core bet is a light-touch identity. A short name-role-one-liner profile produces more natural writing than an exhaustive voice analysis, which tends to make output stiff. Pulls real context so the post cites specifics, not platitudes.

Set author and brief

Which voice, and what is the post for: announce, position, recruit, reflect? One clarifying question at most, then it gets going. It does not interview you.

Claude reasoning
Brand page = company voice. Founder = personal voice. Colleague = build a light profile on the spot.
Gather grounding facts

Search the memory store, then grep specific files for the exact numbers and names. These become a few context bullets so the draft is concrete, not generic.

Supermemory search Read references/
Draft three distinct tones

Professional, personal, and bold, each ready to post. The one rule above all others: it has to read like a real person wrote it, not a brand account and not a machine.

Claude reasoning
Two automatic safety passes

A confidentiality check blocks anything unannounced or sensitive and flags any metric to verify. Then a humanizer pass quietly strips the usual machine tells before you ever see the draft.

Read humanizer-checklist
Iterate, identity locked in

Pick a variant and refine. For a multi-author campaign, the brief stays put and only the author identity swaps out.

/content-ideas Creative generation Project

A brainstorm dump of 15 to 20 big-format ideas: films, podcasts, series, experiential. The design choice that makes it work is restraint on context. It loads only a little, on purpose, so the output stays creative instead of boxed in by current constraints. Most ideas get junked. The job is to surface the one or two worth raising.

Load light, on purpose

Only the project instructions and the latest daily log. Heavy strategy docs are deliberately skipped because too much context narrows the imagination. Past runs are checked so ideas do not repeat.

Read Glob
Spark with current trends

A couple of quick web searches surface cultural moments and viral formats. These are optional fuel, never forced into an idea where they do not fit. If search is slow, this step is dropped rather than allowed to block.

WebSearch
Dump 15 to 20, mixed and specific

Spread across audiences, formats, and effort levels. Every idea is tied to a real asset of the business, never generic. Weird is encouraged. The dump stays unsorted so scanning it feels like discovery, not a report.

Claude reasoning
Save the run for next time

Saved with a timestamp. No rating, no ranking. You cherry-pick on your own time, and the next run reads this file to avoid repeating itself.

Write
/daily-log Compaction pattern Project

The end-of-day counterpart to the morning briefing. It compresses a whole day into one structured file, folds in the day's raw thoughts and meetings, commits everything to git, and refreshes the memory store so tomorrow's session starts with full context instead of a blank slate.

One file per day

If today's file exists, it merges into it rather than starting a second. Re-running later in the day is safe and just adds an evening section.

Glob Read
File exists? Merge mode. New day? Create from template.
Pull the day's threads together

Decisions, discussions, to-dos, intel, ideas, and blockers are lifted from the session, and the day's meetings are pulled in as key takeaways only. Full transcripts stay in their own files and are just linked.

Claude reasoning Granola REST API
Route the brain dump in

Today's raw-thoughts file is read and each entry is filed under the right heading, tightened but kept in your phrasing. The log links back to the full dump instead of copying it.

Edit
Refresh the live workstream list

A marked block in the project instructions is rewritten to the current top items, dropping shipped or dormant ones, so future sessions never read a stale to-do list.

Edit
Commit and push the whole day

Not just the log. Every doc and edit made that day is archived in one commit.

git commit git push
Sync to memory, with a quota guard

A dry run shows what would upload. Ephemeral or regeneratable files are skipped to protect the free quota, but logs, briefs, and strategy docs always sync. Every skip is reported afterward, so oversight happens without pausing the run.

Supermemory sync
04.5

A Typical Day

How the skills, connectors, and memory chain together into a daily workflow.

MORNING
/daily-briefing → calendar, to-dos, overnight comms, priorities

Start-of-day briefing. Pulls today's schedule, yesterday's unfinished items, overnight Slack/email, active commitments, and deadlines. Suggests top 3 focus areas. Read-only.

Check meetings → /save-meeting

Pull overnight meeting transcripts. Save relevant ones to Meeting Transcripts/ with date prefix. Memory tracker updated to avoid duplicates.

PRE-CALL
/call-prep for [person]

Supermemory search + project file scan generates a structured brief. Context summary, talking points, open questions – all in one doc.

WORKING
/ghostwrite → 3 variants → iterate

Content creation for brand page or founder's profile. Supermemory provides context. Humanizer pass strips AI patterns. Iterate until ship-ready.

AS NEEDED
/competitive-intel

Internal scan + Supermemory + web search. What's the competitor doing? What's changed? What does it mean for us?

MID-WEEK
/leadership-update → draft, review, send

Recurring leadership brief. Gathers context from the week's logs, transcripts, and Slack. Presents candidate topics for selection. Drafts structured update with inline doc links. Exports sendable format.

PERIODIC
/content-ideas → 15-20 brand-level ideas → save run

Creative brainstorm dump. Trend-injected, pillar-mixed, complexity-varied. Reads past runs to avoid repetition. Run weekly or whenever you need creative stimulus. Most get junked – the point is surfacing the 1-2 worth shipping.

ASSET WORK
/icon-prompt → paste into image-gen → drop into brand library

When a new asset is needed, the skill emits a brand-locked prompt in seconds. Consistent palette, composition, and negative-space rules across weeks of generations – so the library stays coherent even when multiple people are adding to it.

AD PRODUCTION
Brand-locked prompt → image- and video-gen MCP → manifest CSV → paused-draft pipeline

For ad assets specifically: brand-locked prompts feed into an AI image- and short-form-video MCP, the renders land in a language-tagged folder, and the manifest CSV is the entire campaign spec consumed by the Section 07 pipeline. End-to-end terminal flow – no platform UI clicks, no live spend until a separate manual publish step.

THROUGHOUT
/brain-dump as thoughts arrive

Raw, verbatim capture of ideas, decisions, and to-dos mid-flow. Timestamped into a single dated file. Skills compose here: at EOD, /daily-log reads this file and auto-routes each entry into decisions, to-dos, ideas, and blockers – so nothing is lost between sessions, and the log stays cleanly structured without extra typing.

END OF DAY
/daily-log → git commit + push → Supermemory sync

Compress the entire day into a structured log. Auto-commit all project changes. Auto-sync new content to Supermemory knowledge graph. Tomorrow's Claude starts with full context.

05

Cross-Project: Internal Tools Built on the Same Stack

Seven separate web projects Claude Code also manages – same architecture, different problems. Two are public-facing websites (the consumer side and the supply side); the rest are internal tools, most shipped in an evening or a weekend on the same stack and login patterns. The performance dashboard shows up here because it is a separately-hosted site, and again later as Case Study 8, where the interesting part is the workflow. The Meta-ads lifecycle pipeline stays a case study only (Section 07), because it runs in the terminal rather than as a hosted site.

🌐

Consumer Website

Public marketing site + a ~15,000-page programmatic SEO layer

A full rebuild of the public marketing site, plus a layer that auto-generates a page for every place the company serves.

Stack Next.js 15 + TypeScript + Tailwind + Vercel (static export) · build-time JSON aggregated from raw CSVs · Haversine nearest-hub + farthest-point sampling for neighbour diversity · MinHash LSH similarity gate (the build fails if any two pages are too alike) · no runtime database
🌏

Supply-Side Website

The worker-facing site, built for non-English-first readers across eight languages

The supply side of the business has its own website, separate from the consumer one, because its visitors read different languages and follow a different path.

Stack Next.js 16 (standalone) + Tailwind v4 + lucide-react + Vercel · JSON-bundle i18n with a shared cookie across pages · per-IP rate limiter + server-side bot verification · lazy video embeds · per-language canonicals across eight languages
✏️

AI Copy Generation Tool

A standalone writing workbench for the brand and operations teams

An in-house tool for producing on-brand copy fast, across many formats, for people who do not want to write prompts.

Stack Next.js + Vercel + Firebase (auth + Firestore) + Claude (Opus for quality) · separate codebase, shared stack · whitelist auth · per-user session memory · designed for non-technical operators
📊

Creative Performance Dashboard

A hosted dashboard that replaced a weekly copy-and-email creative review

Instead of a spreadsheet emailed around every week, the team opens one hosted dashboard that keeps itself up to date.

Stack Next.js + Vercel + Firebase (Firestore) · daily cron pipeline (ad-platform API + attribution join) · Claude vision for per-creative narration, cached on asset hash · one canonical document per dashboard view
📋

Hiring Funnel Microsite

A single-purpose JD + form site with a hidden attention-to-detail test

A one-evening build to open a role: a job page, an application form, and a quiet test baked into the thank-you page.

Stack Next.js + Vercel + Tailwind · custom form + third-party form builder · Apps Script webhook to a tracker sheet · hidden Easter-egg endpoint writing extra columns in the same sheet · no auth, no database · shipped in one evening
📽

Hosted Deck Template

A link-first presentation format for internal docs

For internal documents that should read like a deck but also live at a URL: team principles, all-hands, onboarding.

Stack Static HTML + a reusable web component (auto-scaling canvas, keyboard nav, print-to-PDF) + CSS design tokens · Vercel auto-deploy on push to main · GitHub as the source of truth · no runtime framework · one repo per deck, shared token package
🚀

Employee Amplification Portal

An internal tool for coordinated brand campaigns on LinkedIn

When a campaign launches, every employee gets a ready-to-post LinkedIn draft written in their own voice.

Stack Next.js + Vercel + Firebase (auth + Firestore) + Claude · on-demand Opus for quality, lighter model for batch · Slack Block Kit DMs with interactive buttons · cron-based chunked processing (rate-limit safe)
06

Workflow Case Study: A Hiring Funnel, End-to-End

Not every useful workflow deserves to become a skill. Some jobs are big and one-off enough that turning them into a slash command is the wrong investment. But the process underneath is still structured, repeatable, and worth writing down for the next time something similar comes around. This is what that looks like when all four layers work together on a real, messy job: 662 raw applications run through a custom pipeline, ending in a ranked shortlist of 31.

STAGE 0
A one-page job site that feeds a tracker sheet

This is the top of the funnel. A single-purpose web page carries the job description and the application form. A form-builder tool stores each submission. A small script copies every submission straight into a Google Sheet. The thank-you page hides a quiet attention-to-detail test, and anyone who notices it gets flagged right there in the same sheet. The whole thing went live in one evening. (See Section 05 for the site itself.)

STAGE 1
Pull every submission, drop duplicates, one folder per person

The form builder exposes its data through an MCP server, which is just a standard way for the tool to hand its records over to Claude. We pull every submission, then remove duplicates by email address. Each candidate gets a numbered folder holding their raw form answers, CV, profile PDF, and one plain-English summary file that both the reviewer and Claude can actually read later. Original files stay untouched next to their converted copies.

662 raw forms→653 unique candidates
STAGE 2
Turn 1,300+ files into clean text

Every CV and profile PDF runs through a converter. Text-based PDFs get their text pulled out directly. Scanned images go through OCR, which reads text off a picture. The result is small, clean markdown that Claude can read for almost nothing. This is the step that makes the next two stages possible. You can hold the entire pool of 500-plus people inside a single 1M-context session (one chat that can keep about a million words in view at once) instead of paying to re-read images one by one.

187 MB of files→3.3 MB of text
STAGE 3
Cheap rule-based screen, with every rejection checked by a human

Six simple, free checks run first: too few words in the open answers, placeholder web addresses, dead portfolio links (tested with a quick HTTP check that just pings the link to see if it loads, then eyeballed), nonsense in number fields, and an experience cap. Any single rule tripping means reject. That cut 151 of 653. The rule that matters most: the reviewer reads and approves every rejection by hand. The machine cuts are there to save time, not to dodge judgment. A standout caught by a filter can be kept as an override with the reason written down, unless a later rule like the experience cap removes it anyway.

653 candidates→151 cut, 502 left
STAGE 4
Claude scores everyone left, against a strict six-part rubric

The survivors get scored on six things (worldview, voice, proof they build, comfort with AI, how fast they learn, and fit) with set weights and a tough bar where a 5 means roughly the top 5 percent. No outside service, no helper agents. Claude reads candidates in batches of 50 inside one 1M-context session and writes a clean score per person: one sentence of evidence per dimension, green and red flag lists, and a sharp question to ask on a call. 502 people scored in a single run. They land in four buckets, Strong, Promising, Borderline, and Pass, with the cut-offs written down so the ranking can be reproduced.

STAGE 5
Write the verdict into each candidate's own summary file

A small script walks every candidate folder and adds a STATUS block at the top of that person's summary file: the verdict, the weighted score, each dimension with its evidence, the flags, the call question, and any reviewer notes. It writes between two fixed marker comments, so you can run it again after any score change and it just updates in place, never duplicating. The reviewer opens one file per candidate and sees the whole picture in one place they can scan. Nothing is hidden in a separate sheet, and nothing gets lost between sessions.

STAGE 6
A manual override layer, both ways, fully reversible

The rubric sorts; it does not decide. The reviewer can move people up (Promising to Strong because of a signal the rubric missed) or down (Strong to Pass for a red flag it under-weighted). Every override keeps the original_verdict in the file, so the move can be undone and the rubric's own accuracy stays checkable. The ranked list rebuilds from those files, so one re-run pushes every override through the whole system.

STAGE 7
Take-home round, with its own rubric

The top bucket (31 people in this run) gets a take-home task on a 48-hour clock. It is judged on a separate rubric built for what the task actually tests: craft under time pressure, judgment, taste. The Stage 4 rubric was tuned for the quality of an application, not the quality of a finished piece of work, so it would be the wrong lens here. Two stages, two scoring lenses: different weights, different dimensions, different flag lists. The plumbing stays the same (one file per candidate, the same aggregate script, the same STATUS block), with only the rubric swapped out.

📈

Why this is a pattern, not a one-off

The transferable principles – next funnel, next bulk review, reuse the same shape
🧾
Cheap filters first

Free rule-based cuts run before paid AI scoring, which runs before scarce human review.

📁
One folder per person

Each candidate gets one folder with the raw files and a single summary both the human and Claude read.

🔄
Safe to re-run

STATUS blocks sit between fixed markers, so re-running updates in place and never duplicates.

♻
Overrides keep history

Manual moves save the original verdict next to the new one, so any change is checkable and reversible.

🎯
A rubric per stage

The lens that ranks applications is not the lens that ranks take-homes. Same plumbing, swapped rubric.

📝
Resumable from day one

Two top-level files record the current state and decisions, so a fresh chat picks up the work cleanly.

⚙️
What could become a skill
  • Pulling submissions, removing duplicates, and building one folder per person.
  • Converting files to clean text, including OCR on scanned images.
  • Running the cheap rule-based screen, which is the same every time.
  • Writing the STATUS block between fixed markers, which is pure plumbing.
🧠
What stays human
  • Approving every rejection, so the machine never quietly drops a person.
  • Calibrating the rubric and deciding what a top score actually means.
  • Choosing when to override the ranking up or down.
  • So this stays a set of scripts and notes for now. A funnel run every few months does not earn a single command, and wrapping it in one would either hide the judgment or make it brittle. Run it every quarter and it becomes worth crystallizing.
07

Workflow Case Study: Meta Ads Lifecycle from the Terminal

A second workflow that is not a skill. This one runs the whole life of an ad campaign from the command line: making it, publishing it, changing it, improving it, and measuring it. Each step is a small Python script fed by a spreadsheet or a campaign id. The only way money ever gets spent is a separate publish step you run on purpose. The hiring funnel was about the reading side (scoring, filters, overrides). This is the writing side, with a short measurement loop wired straight back into the same terminal.

STAGE 0
Make the video assets, drop each into a language folder

Short video clips are generated by an AI video tool reached through MCP (a standard way to plug an outside tool into the assistant), using on-brand, brand-locked prompts. Each finished file lands in a folder named for its language (creators/hi/, creators/kn/, creators/ta/, and so on). The same campaign can then go out in eight regional languages with no renaming later.

on-brand prompt→8 language folders
STAGE 1
Two spreadsheets describe the whole campaign, no clicking

The entire campaign lives in two files. manifest.csv has one row per ad: which video, which language, which audience, which copy id, which targeting. copy_variants.csv has the body, headline, and description for each copy id. That is all a person has to fill in. Anyone who can edit a spreadsheet can build a campaign. No clicking around the ad platform, no copy-paste between boxes, no risk of dropping the wrong language into the wrong ad set.

STAGE 2
Check, upload, build creatives, build campaign. One script each, progress saved to disk

Five small scripts run in order. 00_test_access checks the login works and the ad account is reachable. 01_upload_videos reads the manifest, pushes every video, and saves state/videos.json matching each filename to its platform video id. 02_create_creatives builds the ad creatives and saves state/creatives.json. 03_create_campaign builds the campaign, ad sets, and ads, all left paused, and saves state/campaign.json. 04_audit_draft just prints the whole tree and writes nothing. Each step saves its own progress file. If one step fails, you re-run only that step. It is safe to re-run without making a mess, and nothing earlier is lost or duplicated.

5 scripts→3 saved state files
STAGE 3
Everything stays paused. The audit print-out is the gate

By the end of Stage 2 the full campaign exists on the ad platform, but paused. The audit script walks the tree and prints what was built at every level: the campaign budget and goal, each ad set with its audience and placement, each ad with its creative and language. The reviewer reads that print-out before approving any spend. The naming convention keeps things separate. Every campaign from this rail starts with a marker prefix, so it sorts apart from live campaigns and can never be mistaken for one that is spending money.

STAGE 4
Publishing is its own script, with a flag you type out

Going live is a separate script you run on purpose. 05_publish.py flips one campaign from PAUSED to ACTIVE, and only the campaign whose id you pass as a flag. There is no "run everything" button. There is no shortcut. The reviewer types out the id of the campaign they want live, and only then does money start moving.

STAGE 5
Change a live campaign with small, one-job scripts

Once a campaign is live, every change is its own small script: budget tweaks, audience edits (say, adding an exclusion list or narrowing the age range), creative swaps, on and off switches. None of them touch the manifest. Each takes a campaign or ad-set id as a flag and writes one line to an audit log. The setup is a flat _lib.py of small helpers plus one script per kind of change. It is one script per change instead of a single do-everything tool because the script itself is the record. Running _update_audience_female_18_45.py against a campaign id still reads clearly six months later. An interactive console session never does.

STAGE 6
Pull the results back, using the same Marketing API to read

The same login that created the campaigns now pulls the numbers back. A set of read scripts covers slices by creative, by ad set, by city, and by weekly trend, each one writing a plain CSV next to its raw data dump. The goal is not fancy reports. It is being able to reproduce any breakdown from the terminal, on demand, without waiting for a dashboard to refresh. Discipline on what counts: every read filters to a minimum spend and a minimum group size, so one freak ad set can't drag a typical-result number around. The verdicts are fixed rules read straight off the data: INSUFFICIENT_SPEND, INSUFFICIENT_DATA, SIGNAL_BROKEN (for example, zero conversions on iOS, which gets flagged but never auto-killed, because the tracking itself may be wrong). The dashboard in Section 08 is just one user of these scripts. You can also run them yourself with different flags.

raw API data→filtered CSV + verdicts
STAGE 7
Improve the campaign. Verdicts decide the next change

This is where the loop closes. Stage 6's verdicts feed Stage 5's change scripts. An ad set marked UNDERPERFORMING gets paused by the same id-flag script that pauses anything else. A creative doing well across the board gets more budget through the budget script. A case where the tracking looks doubtful gets a flag in the audit log but no automatic action, because a human stays the gate for any iOS-side change. Nothing here drives spend on its own. It just shrinks the old "pull a CSV, argue in a meeting, click in the dashboard" loop down to "run a verdict script, run the matching change script," both in the same terminal session.

⚙️

Why this works as a non-engineer’s ad workflow

Different job, same building blocks as the hiring funnel
📊
Spreadsheets in, spreadsheets out

The campaign is built from CSVs and the results come back as CSVs. Plain text the whole team already trusts, both directions.

🔄
One job per script

Each step saves its progress, so a failed video upload only re-runs that step and the script name is the record.

⏸️
Paused by default

Nothing reaches live spend without a separate, deliberate command. The audit print-out is the line; a human crosses it.

⚙️
The skill-ifiable rails
  • The check, upload, and build steps run the same way every launch.
  • Progress-file saving between steps is plain bookkeeping.
  • The verdict rules read straight off the data, no judgment needed.
🧠
Stays human
  • Reading the audit print-out and deciding what is safe to publish.
  • Deciding when a doubtful-tracking flag means act and when it means wait.
08

Workflow Case Study: A Performance Dashboard

A third workflow that isn’t a skill, and the read-side twin of Section 07. The marketing team used to ship a weekly ad review as a pile of spreadsheets and a PDF over email. This case study walks through the pipeline that swapped that ritual for an always-on internal dashboard. The numbers come straight from the ad platform’s data feed and from the attribution provider (the tool that figures out which ad actually drove an app install), and every ad gets a plain-English description of what it shows. The point isn’t the code. It’s the shape that lets a non-engineer run a self-refreshing data pipeline from the same terminal where the rest of the work happens.

STAGE 0
Two data feeds, stitched together by city

The two sources see different halves of the picture. The ad platform’s data feed knows what you spent and how many people saw and clicked each ad. The attribution provider knows how many app installs happened, broken down by city. Neither one alone can tell you the cost per install in a given city. So the pipeline pulls both and matches them up by city, date, and platform. The result is one clean row per ad group per day. The whole value is that the two sides now sit together in a place you can actually query. Before this, that match lived in a hand-built spreadsheet formula nobody trusted.

two separate feeds→one joined row per day
STAGE 1
Roll it up to one row per ad and one row per ad group

Those clean rows get rolled up into two tables. One has a row for each individual ad. The other has a row for each ad group over the last 30 days. The roll-up is done over a few time windows at once, so you can see the last 30 days, the last 7 days, and the week-by-week trend. Each ad is scored against the middle of its own peer group, not against a fixed target. Low-spend and tiny-sample rows are dropped first, so one lucky day can’t bend the benchmark for everyone else.

STAGE 2
A clear verdict on every row, by the rulebook

Every row gets one of a few fixed labels: strong, promising, underperforming, not enough spend, not enough data, or signal broken. The thresholds change with the goal, so an ad meant to drive website sign-ups isn’t judged by the same bar as one meant to drive app installs. There’s also a doubt check built in. When measurement is known to be unreliable on certain phones, a zero-install ad is flagged as signal broken instead of failing, because the zero might just be a tracking gap. Each verdict carries a one-line reason, so you can see why a row landed where it did without re-running the math in your head.

STAGE 3
A plain-English caption for each ad, written once and saved

The hard part of any ad dashboard isn’t the numbers. It’s knowing which numbers belong to which ad. So an image-reading pass looks at the still or first frame of each live ad and writes one line describing what it actually shows: the setting, who’s in it, and the words on screen. That line sits right next to the verdict, so the table reads like “testimonial style, indoor setting, on-screen offer” instead of a meaningless ad ID. Each caption is saved against a fingerprint of the image, so an ad that hasn’t changed never gets described twice.

opaque ad ID→plain-English caption
STAGE 4
Save it as one document the website just reads back

The pipeline saves one clean document per view of the dashboard. There’s a view for the per-ad scorecard, one for the ad-group table, one for the weekly trend, and one for the city breakdown, each with the finer per-city and per-week slices filed underneath. That’s what lets the website be a thin reader: fetch one document, show it. The website never talks to either data source itself. The keys, logins, and rate limits all stay safely on the server. The dashboard only ever reads back what the pipeline already wrote.

live API calls per view→one document read
STAGE 5
A daily auto-refresh that pings the team when it’s done

The pipeline runs itself once a day on a schedule. When it finishes, it drops a one-line note into a team channel: rows pulled, rows scored, captions reused from cache, and any errors. So anyone can glance at it and know whether yesterday’s data is fresh. It refreshes on a timer, not on demand. That’s the point: the team reads the dashboard, nobody has to run anything. If someone wants a slice the dashboard doesn’t show, they run the read-side scripts from Section 07 against the same sources, in their own terminal. The dashboard is one way in, not the only way in.

📊

Why this is the read-side twin of Section 07

A non-engineer’s data pipeline that holds up because the lines between the parts are clean

The same handful of habits carry over from the other case studies. The pipeline does all the heavy lifting and the website just reads the result. The plain-English verdict comes first, before any chart. Every roll-up only trusts cohorts big enough to mean something. The slowest step gets saved so a second run the same day is nearly free. A weekly email artifact becomes always-on hosted data. And the daily timer plus a few hand-run scripts is the real interface, not a dashboard you have to babysit. Three of those are worth pulling out on their own.

🧱
Pipeline writes, website reads

All the logins and rate limits live in the pipeline. The dashboard is a static reader you can’t break by sharing the link.

✅
Verdict before chart

The plain-English call with its reason is the headline. Nobody has to reverse-engineer a rule out of a graph.

💾
Save the slow step

The image-reading pass is the costliest part, so its output is cached. Unchanged ads are never described twice.

⚡

What got turned into a command, and what stayed by hand

The deterministic bulk stays a timer; the eye-judgment steps became small commands

The mechanical core (pull, stitch, roll up, score) stays a daily timer. Wrapping “refresh the data” in a command would just bring back the chore the dashboard was built to kill. But an earlier version of this study guessed that any step needing a human eye might one day become its own command, and that is exactly what happened. Two of these stages later became small dedicated commands: the one that turns an image into a written read, and the one that pushes the reviewed result live. Each is a place where a person’s judgment is the actual value, so each earns a deliberate, human-triggered step rather than a silent auto-run.

⚙️
The parts a command can own
  • Reading each image and drafting a first-pass caption runs the same way every time.
  • Building the numbers-only scaffold for a human to fill is pure, repeatable setup.
  • The publish step’s mechanics, with its stop-and-confirm gate, are plain validation logic.
🧠
Stays human
  • Turning a still into a real verdict, a design read, and a fix is judgment, not arithmetic.
  • Deciding the data is clean and worth pushing live before anyone acts on it.
09

Workflow Case Study: AI Image + Video Generation, End-to-End

A fourth workflow that is structured but not yet a slash command, this time on the creative-production side. The idea is simple. Short vertical video keeps winning as an ad format, but filming a fresh shoot for every idea is slow and pricey. AI image and video generation, reached through an MCP (a plug-in that lets Claude call an outside tool), lets a non-engineer test ideas for a tiny fraction of shoot cost. The catch is that the workflow around it has to be tidy. This case study walks through that workflow: how you write the brief, how each look is matched to the right model, why the brand bits stay out of the generated clip on purpose, and how each round builds on the last.

STAGE 0
Spot a format in the wild, then write down a clear hunch

Every pilot starts by noticing a format. A rival or a nearby brand keeps shipping the same recognisable look (satisfying close-ups, fast before-and-after cuts, one continuous walk-through) often enough that the format, not the product, seems to be doing the work. This stage is about writing down exactly what you think is winning. Maybe it is the vertical shape, the real-world sound with no voiceover, or the tight eight-second build that lands on a clean payoff. Put it in a one-pager. If the hunch is fuzzy, everything after it drifts.

STAGE 1
Pick the look first, then drop a service into it

One choice makes everything later scale. Pick the formats first, with no service attached, then slot a service into each one. The look is the reusable template. The service is the thing you swap in. Once a look-and-service pairing wins, rolling it out across the rest of the menu is cheap, because you are not re-inventing the idea for each category. This is the gap between a look that is tied to one service (“a video about one specific service”) and a look you can reuse (“a fast before-and-after cut you can drop any service into”). The reusable one keeps paying off.

1 winning look→N services for free
STAGE 2
Keep one style menu, with a status and a reason on every row

One single file lists every look you are weighing up (quiet close-up sound, fast time-lapse, oddly satisfying restoration, slow-motion ramps, extreme macro, first-person view, reverse playback, stop motion, and so on). Each row carries a status: in this pilot, save for round 2, or rejected, plus a short reason. The pilot only builds a few of them. Everything else stays parked but still in view. That one file is your roadmap, your budget plan, and your record of what you said no to. Next round, you do not have to brainstorm from scratch to recall why a look was set aside.

15+ looks brainstormed→3-4 built this round
STAGE 3
Match each look to the model that is best at it

The image and video tool offers several models, each good at a different job. One is built for a single cinematic shot. One stitches three or four cuts together inside one clip and keeps the sound flowing across them. One keeps the same character looking the same across a series. The style menu records which model goes with which look, plus the limits to watch (how long it can run, whether it makes its own sound, whether it needs a starting image). Do not push one model to do every job. The wrong model on a look is the easiest way to burn credits and learn nothing.

STAGE 4
Write the prompt as the full spec, shot by shot

The prompt is the brief. For each pilot ad it spells out the shape (vertical or wide), the total length, and a shot-by-shot timeline with timestamps (Shot 1 runs 0 to 2 seconds, Shot 2 runs 2 to 4 seconds). It also describes the sound (textures, beats, voiceover on or off) and the look (lighting, how much is in focus, the feel of the lens). The brand rules live inside the prompt, not in a side note: no rival names, only approved wording, no on-screen text that clashes with what is public. Two rules keep generation cheap. No people on screen, which avoids faces shifting between re-runs and keeps likeness risk out of the pilot. No branding inside the clip, so no logo, no call to action, no voiceover. The brand layer is added later in editing.

STAGE 5
Generate, name well, and log every attempt

Each prompt is run against its chosen model, and the finished file lands in a generated/ folder. The filename carries enough to make sense of a clip on its own, no opening needed: id, look, service, model, and version, all in the name. A simple log file records one line per attempt, with the prompt that was used and the path to the file. If a clip needs a re-run with a tweaked prompt, the first attempt stays in the log. The difference between the two attempts is itself a useful clue for the next round.

STAGE 6
Hand to the editors, who add the brand layer on top

Editing is where the brand goes on: an end card in brand colours with one call to action, an optional small logo, and optional service-specific captions in the last second or two. The editors add to the clip. They never re-generate it. That one rule is what keeps generation costs predictable. Final filenames follow the same naming pattern as the rest of the ads, so each file drops straight into the spreadsheet that the Section 07 pipeline reads. The handoff note spells out what they may and may not touch: trimming, the brand layer, and captions are fine; re-cutting the generated footage is not.

raw generated clip→finished branded ad
STAGE 7
Work in rounds: explore in round 1, double down in round 2

Pilots run in rounds, not one big wave. Round 1 builds the in-pilot looks across two or three services and stops. The performance read from Section 07 and Section 08 (careful, like-for-like verdicts on how many people stop, how many keep watching at three and six seconds, and how many click) tells you which look-and-service pairing earns the next spend. Round 2 grows in two directions. More versions: three or four small variations on the winner, run on a cheaper model in the same family. More services: the winning look applied to the next two or three services. Each round also promotes one parked look from the menu, so the set of things you are testing keeps refreshing.

🎬

Why this shape compounds

The principles that make AI generation tractable for a non-engineer
A handful of habits are what make AI generation workable for a non-engineer. The renders feed the spreadsheet the Section 07 pipeline reads, and the performance verdicts from Section 08 point to the winner you double down on next. The case studies do not run in parallel; they hand off to each other.
🎬
Generate the hook, not the ad

The clip is pure motion and material. Logo, captions and call to action go on later in editing.

🧩
Look is the template

One winning look drops onto many services for free, because the service is just the swapped-in part.

📋
One style menu

In-pilot, round 2, or rejected, each with a reason. Roadmap and reject log in a single file.

🎯
Right model per look

Pick the model that suits each look. The wrong one burns credits and teaches you nothing.

🔒
Brand rules in the prompt

No people, no in-clip branding, no rival names, baked in. The clip can only be what the rules allow.

🔄
Rounds, not waves

Round 1 explores. Round 2 doubles down on winners and promotes one parked look each time.

⚙️
The parts a skill could take over
  • Turning a chosen look, service and model into a full shot-by-shot prompt with sound, look and brand rules built in.
  • Firing the generation calls, which run through the tool the same way each time.
  • Naming and logging each clip so it slots into the spreadsheet downstream.
🧠
Stays human
  • Deciding which format to test, which service to drop into it, and what about the sound is doing the work.
  • Designing the rounds: a slash command would either pre-pick the idea or need so many flags it loses to a plain written brief.
10

Workflow Case Study: Product Design from HTML to Figma

A fifth workflow that is not a skill yet, this time on the product-design side. Designing a screen usually starts the slow way: open Figma and push pixels around in the file. This case study does it differently. The ideas get worked out in HTML, where changing text is faster than moving pixels. Every version is drawn at real phone size on one page so you can compare them side by side. Only when one version is locked does the work cross into Figma, through a capture step that turns the page into a real design file. From there it splits two ways. A designer can add polish before it ships, or, when the brief is simple, developers read the captured file directly and build straight from it. That second path removes a whole handoff round.

STAGE 0
Take the brief apart first

The brief usually shows up as a Figma export of an existing screen, a copy doc, some raw images, the dimensions read off dev mode, and a list of colours. The first job is to read all of that and lock the things that cannot move: the screen width (360px for a phone, say), the brand colours and spacing, and the right font for each surface. Different surfaces use different fonts. The app might be on one font and the website on another. Pin that down now, or people end up swapping fonts after handoff and the design drifts. Each image is opened and described using the multimodal model (the model can read pictures, not just text), so the right image lands in the right spot later no matter how it was named on export.

STAGE 1
Draft in HTML, not in Figma

The first thing built is an HTML page, not a Figma frame. While the idea is still moving, the cost that matters is how fast you can change it, and HTML changes faster than pixels. Edit a heading, swap a tile, hide a section, drop a price. Each one is a one-line change you see the moment you refresh. The HTML lives in git, so every version is saved, and there is no plugin or auto-layout to fight. The fiddly craft work (clean hairlines, exact spacing, sharp alignment) waits for later. That belongs after the capture step, not now.

STAGE 2
Three or four real directions, not three of the same

This stage makes three or four versions, and each one bets on a different idea. Reassurance-led is calm, with lots of white space, thin lines, and no icons in the body. Feature-led is a dense grid you can scan fast. Visual-led reads like an illustrated explainer with a vertical timeline. The hybrid takes the best move from two of the others. The whole point is that they disagree. They have to compete on different logic, not be three coats of paint on one idea. That forces the conversation onto the concept itself, not the decoration.

STAGE 3
Line them up side by side at real phone size

All the versions sit as columns on one wide HTML page, each drawn at the real device width (for example, four columns of 360px each, set with grid-template-columns: repeat(4, 360px)). Real status bar, real header buttons, real button position. Nothing shrunk to fit. Seeing them side by side at real size beats flicking between tabs at the wrong size. You choose by scrolling, instead of trying to hold three tabs in your head. Building at phone size from the start also kills the late “this looks weird on mobile” surprise. The phone you will ship on is the phone you design on.

STAGE 4
Refine on the same page, one small edit at a time

Once one version is clearly ahead, you tidy it up with small edits on the same comparison page. Hide a section, swap a heading, trade a stuck-to-the-bottom button for a centred one, drop in a banner once the image arrives. The HTML stays the single source of truth and the page grows with the work. Because each change is a small text edit, it is easy to undo and easy to review. There is no plugin state to lose, no auto-layout quietly shoving the next thing over, no version history to dig through.

STAGE 5
Add the capture script and serve the page locally

When a version is locked, two small setup steps happen. One line goes into the top of the HTML: a capture script tag (an MCP is a connector that lets the model talk to an outside tool, here a design tool) pointing at its public capture address. Then a small local web server runs in the page’s folder, for example python3 -m http.server 8901. The capture script will not run from a plain file on disk (a file:// path). It needs the local server, so that step is not optional. With both in place, you ask the tool for a capture ID and pick where the result should land: a new file, an existing file, or the clipboard.

STAGE 6
Turn the rendered page into a real Figma file

You open the served page with a few capture settings in the URL: the capture ID, the address, and a short delay so fonts and images finish loading before the snapshot. The script grabs the page exactly as the browser drew it and sends it to the tool, which rebuilds it as a real Figma file. Frames stay frames, text stays editable text with the right font, weight, and line spacing, images become image fills, and shapes become vector paths. You check the address every few seconds for a status, and once it reads completed you get a Figma link back. This first version is a plain copy of the page. It matches the HTML pixel for pixel but does not yet use the reusable design-system parts. That gap is what Stage 7 is about.4-column HTML page→editable Figma file

STAGE 7
The fork: designer path or developer path

Two paths open from that captured Figma file, and the brief decides which one you take.

Designer path. A designer opens the captured frames, swaps the plain copied pieces for the reusable design-system parts, fixes any layout that shifted, tightens the spacing, and ships the polished version. The captured file is the layout reference, and the design system adds the craft.

Developer path. The captured file already matches the page exactly. When the brief is simple and does not need polish (an explainer page, an internal tool screen, a plain hero), developers read the Figma file straight away and build from it. That skips the designer round trip entirely. The same file that took well under an hour to draft in HTML is now a ready-to-build handoff.

🎨

Why this shape compounds

What lets a non-designer ship production design
✏️
Diverge in HTML

While the idea is still moving, editing text is faster than nudging pixels. Polish comes after the capture, not before.

📱
Compare on one page

Three or four columns at real phone size on a single page beat one screen per file. You pick by scrolling, not by memory.

📲
Real size from the start

Design on the phone you will ship on. It kills the late “this looks weird on mobile” surprise that shrunk desktop mockups bring in.

🎯
Brand rules go in first

Colours, fonts, and spacing go into the CSS up front, and the idea moves inside those limits. Different surfaces, different fonts.

🔗
Capture is the bridge

Without it, HTML mockups stay mockups. With it, a four-column page becomes a real Figma file everyone can open in their own tool.

⎆
Two ways to hand off

Simple briefs go straight to developers. Briefs that deserve craft go to a designer. The fork is decided by the brief, not the file.

This loops back to Section 02. The Figma connector has a read side (pull design context, look up components, code-connect) and a write side (turn a served page into a Figma file). They are the same connector seen from two ends. Most teams use only the read side. This case study lives on the write side.

⚙️
The part a skill could own
  • Add the capture script tag to the page.
  • Start the local server and request a capture ID.
  • Open the URL with the right settings and wait until it reads completed.
  • Hand back the Figma link. After a few runs this stops needing any thought.
🧠
The part that stays human
  • Choosing three or four directions that genuinely disagree, not three takes on one idea.
  • A slash command here would either pre-pick the layouts, which defeats the comparison, or take so many options it loses to a plain written brief.
  • So the concept work stays a person’s call. Only the capture-and-export plumbing is worth turning into a skill.
11

Workflow Case Study: A Presentation Deck as a Reproducible Program

A leader needs a pitch deck. It has to survive tough questions, hold up through many rounds of edits, and look the same on every slide. The obvious move is to open a slide editor and start dragging boxes around. This does something different. The deck is built as a small program: a real, editable presentation file that scripts generate and update, guided by a written design spec and a story plan. Charts are live charts you can click into, not flat screenshots. Every save is checked for damage. The whole file is version-controlled, so you can always rebuild it. The same method was run on two separate decks in two different visual styles. That is the proof it is a repeatable system and not a fluke. The looks changed, but the rails stayed the same.

STAGE 0
Fix the story before you touch a single slide

Start with the story, not the design. Take a well-known pitch structure (a six-beat arc: open, hook, the insight and the product, the results, the team, the ambition and the ask) and boil it down to a short written brief. Then write the deck’s story out as plain prose, where each line becomes a slide headline. Hold the current deck up against that arc and spot what is thin, missing, or bloated. Do all of this first. If the spine of the story is wrong, no amount of pretty layout will save the deck.

STAGE 1
Build it as a program, never as flat images

The deck is made and edited with a scripting library: one script per slide, plus shared helper files for shapes, text, the logo, and font cleanup. That keeps the whole thing rebuildable and version-controlled. The hard rule: every chart is a real, editable chart with its numbers still inside it, and every table is a real table. Nothing is a flattened image of a chart. A reviewer can open the data behind any bar, and the file stays easy to maintain instead of rotting into a stack of screenshots nobody can edit.

flat chart images→live editable charts
STAGE 2
Rank your sources. The leader’s own content wins

Inputs get ranked, not mixed together. The leader’s own words and section order are the single source of truth for positioning, copy, and story. Their content wins every time. A colleague’s revised draft is used only for the number-heavy slides, for structure and data, and any made-up prose in it gets cut on sight. A live data source (a shared spreadsheet plus a few one-off exports) feeds the charts. Our job is to add design and clarity on top, never to invent brand-new sections. This ranking is what keeps the deck from drifting away from the person it actually belongs to.

STAGE 3
Handle reviewer notes one at a time, in small narrated batches

Every reviewer note becomes its own ticket in a tracker, each tagged with a clear status: do it now, waiting on a decision, needs an asset, parked, or done. For each one the loop is explain → recommend → approve → build → render → check. Say back what the note is asking, suggest an approach and its trade-offs, get a yes, build it, render it, and check it against the original ask. Make small, precise edits in small batches, never one big sweeping rewrite. A small change makes a slip-up easy to spot, while a big pass hides it.

STAGE 4
Review through an offline render loop, slide by slide

One script renders the file on your own machine, with no browser and no screen needed: a local office engine turns it into a PDF, which is then split into one image per slide. That means you preview the real fonts and real charts with nothing sent to the cloud. The reviewer studies the rendered images one slide at a time. The editable file itself is only opened right at the very end. Nothing ever goes up to a cloud editor, which would flatten the live charts and swap the fonts. The leader does the single final export. The render loop is your eyes, and the source file stays untouched until it is genuinely done.

STAGE 5
Lock the design system, and learn where it bites

One written spec runs everything: a single font with its real weight files, a fixed palette by exact hex code, a full set of text sizes with a hard minimum, a layout grid with the header and footer always in the same spot, and set templates for dividers and the cover. The look is flat with no boxes. Card backgrounds and drop shadows are removed in two places, both where they are set directly and where the theme sets them, because shadows hide in both. Chart labels are a small bit of text plus a thin arrow, placed in the gap just above the mark and never on top of it. The big trap: name fonts by family + bold, never by a specific style name like an exact weight string. The style name roughly matches in the render engine but silently breaks in some editors, so it looks fine in preview and then fails on the leader’s computer.

STAGE 6
Check the file for damage on every save

Reviewer comment threads sit in their own parts of the file, so wiping and redrawing a slide, or adding a new one, keeps them safe. But every save still gets checked by cheap automatic tests instead of trust. The number of comments has to stay the same (a simple count). The frozen master copy is checked by a fingerprint (a checksum) to confirm nobody touched it. Edits only ever happen on a working copy. The clean as-received copy and the master are never edited. And because the footer page numbers are typed-in text rather than fields that count themselves, adding any slide kicks off a renumber pass to fix the order. These checks are boring on purpose. A steady comment count and a matching fingerprint take milliseconds and catch the quiet corruption your eyes would miss.

STAGE 7
Once it is hand-polished, freeze it. Build new slides on the side and drop them in

After the leader hand-polishes the deck, it goes hands-off. The generator scripts are not re-run on it, because they would wipe out the polish and break the consistency the polish bought. It also is not edited in place. Any new slide is built as its own standalone file using the same design spec, and then just that slide is copied (injected) into the deck. The build scripts turn into a record of how the slides were first made, not a pipeline you keep running. The polished file is frozen, and new work joins it through a careful drop-in, never a rebuild.

regenerate whole deck→inject one new slide
STAGE 8
Keep a separate notes layer that grades the deck against the story arc

A separate advice doc maps every slide onto the story arc and suggests what to add, what to cut or merge, and how to reorder, with the reason for each move tied back to a specific rule in the framework. This on purpose keeps the mechanical work (which the program does) apart from the positioning calls (which stay with the leader). It frames the big-payoff moves, like adding the missing opening and closing, trimming a middle that over-proves its point, and naming the insight, in a way that sharpens the story without making the deck longer. The notes layer is where the opinion lives, kept out of the code so the human stays in charge of the story.

🎨

Why this shape compounds

The few habits that let a deck survive scrutiny and a dozen rounds of edits
📊
Editable beats frozen

Real charts with live data and real tables that anyone can open and question, not pretty screenshots.

📖
Story before slides

Write the arc as prose and grade the deck against it before designing a single page.

✂️
One note at a time

Explain, recommend, approve, build, render, check. Small batches make slip-ups easy to spot.

🥇
Rank your sources

One person’s content is the truth. Other inputs give data or structure only, and made-up prose gets cut.

🔒
Lock the spec, learn the traps

Exact tokens and a fixed grid, plus the gotchas (the font naming trap and two shadow sources) learned once.

✓️
Guard every save

A steady comment count, a fingerprinted master, an untouched original, and a renumber after inserts.

❄️
Freeze, then inject

Once it is hand-polished, build new pieces on the side and drop them in, rather than rebuilding the whole.

🔗
Same write-side discipline

Build it natively, preview offline, and never round-trip through a cloud editor. A deck instead of a page, same rule.

⚙️
The skill-ifiable rails
  • The offline render-and-split review loop runs the same way every time.
  • Font cleanup is mechanical: name by family plus bold, flatten both shadow sources.
  • The save-time guards are pure checks: comment count, master fingerprint, footer renumber.
  • The build-on-the-side-then-inject hand-off is a fixed, repeatable sequence.
🧠
Stays human
  • Who the deck is for, and which one proof point to lead with.
  • What the named insight actually is, and how to frame each number positively.
  • Calls that reshape the whole arc and differ for every deck and every reviewer.
12

Workflow Case Study: An Icon Pipeline, Prompt to Shipped Asset

A skill does not have to be the whole job. This one generates a single image prompt, but that prompt sits inside a longer pipeline, and the skill itself was the hard part to build. Here is the full path from a locked visual system to a finished icon dropped into the app.

STAGE 0
Building the skill is the real work

The skill reads one locked style guide as its source of truth and assembles an image prompt to match it. Writing it once was not enough. The first prompts produced inconsistent icons, so across about seven rounds of generating real icons and seeing what broke, seven recurring failure modes showed up: an icon cropped at the edge, a subject snapping back to its default orientation, every element collapsing into one muddy colour, and so on. Each one became a belt-and-suspenders rule: describe what you want, and separately ban the failure, because either on its own is unreliable.

STAGE 1
One command, one prompt

Running the skill with an icon name reads the style guide, picks the right archetype (a single object, a small scene, or a flat feature icon), then assembles the full prompt: the positive description, the avoid-list, and the subject-specific negatives. It saves the prompt and logs it, so the library keeps a record of exactly how every icon was made.

icon name→ready-to-paste prompt
STAGE 2
Generate, then judge

Paste the prompt into Gemini (its Nano Banana 2 image model) and read back the rendered icon. This is the step a human judges: does it match the system, or did a new failure mode slip through? A miss here is feedback, and sometimes it becomes a new rule back in Stage 0.

STAGE 3
Clean

Remove the background so the icon sits on transparency, ready to drop onto any surface in the app without a white box around it.

STAGE 4
Export to the app's format

Hand the cleaned file back to Claude and export it to the exact size and format the app's icon set uses. One step, no manual resizing, and the asset is ready to ship.

transparent PNG→328×328 webp
🎨

Why this is a pattern, not a one-off

The transferable principles – next visual system, next generate-and-finish pipeline, reuse the same shape
🪨
Encode failure modes, not just goals

The skill's real value is the seven things it learned not to do, each one paid for by a bad render.

🎯
Belt-and-suspenders prompting

State the requirement and separately ban the failure. On strong-default subjects, either alone is unreliable.

🔗
A skill can be one stage in a pipeline

It emits the prompt; other tools and a human do the middle; Claude closes the loop on export.

📄
One source-of-truth file

The skill always reads the same style guide, so the system stays consistent as the icon set grows.

🔄
Iterate against reality

The rules came from generating real icons and seeing what broke, not from theory written up front.

⚙️
What is the skill (the mechanical rails)
  • Read the locked style guide and pick the right archetype.
  • Assemble the prompt with its avoid-list and subject-specific negatives.
  • Save the prompt and log it for the library record.
  • Export the finished file to 328×328 webp.
🧠
What stays human
  • Judging whether a render actually matches the system.
  • Deciding when a new failure mode deserves a new rule.
  • The generate and background-removal steps that need a designer's eye.
↑ Contents