A framework for running non-engineering work from the terminal
Every Claude Code "work OS" runs on the same stack. Configure these four layers and the system works for any domain.
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.
Meeting transcripts, summaries, attendees
Channel search, DMs, drafts
Calendar, Gmail, Drive, Sheets, GDoc handoff
Form-builder schema + submissions
Read: campaign spend, installs, creative-level performance · Write: video uploads, paused-draft campaign creation
GA4 property reports, realtime, custom dimensions
Organic queries, page performance, indexing health
Product analytics – funnels, retention, event-level cohorts
Mobile install attribution – acquisition + retargeting cohorts joined to ad-level spend
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)
AI image + short-form video generation for ad assets and brand visuals
AI avatar / presenter video generation for talking-head and announcement clips
Local audio transcription (GPU-accelerated)
Secondary machine for CPU-bound pyannote workloads
Browser automation, screenshots, competitive scrapes
Persistent knowledge graph – semantic search across every synced doc
Second-opinion passes + long-context research via alternate models
Live web search + fetch – real-time research and source retrieval
Version control, auto-push, audit trail
Internal tool deployment, env management
Auth + Firestore for internal tools
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.
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.
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.
"Use 'team members', not 'resources', when you talk about people on the team."
It saves a small file with the rule, the reason it matters, and when to apply it.
"The project tracking sheet lives at this Google Sheet link."
It notes where to look the next time that topic comes up.
Claude reads the MEMORY.md index and loads the memories that matter. No prompting needed. It already knows your preferences and your context.
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.
The auto-memory system works per-project. To build a persistent, searchable knowledge graph across everything, I integrated Supermemory via SDK.
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/.
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.
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 ReadUnfinished to-dos from the latest log carry forward. Anything still open across two logs is flagged "open 2+ days" so slow leaks get caught.
ReadRather 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 CLIOn 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.
ReadPicks 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 reasoningPull → 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.
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 APIKeeps 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 reasoningOne 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 cacheSpeaker labels get real names, social chit-chat is trimmed, and the meeting is reshaped into one consistent skeleton:
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 trackerA 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.
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 reasoningStart with Supermemory, the project's searchable memory store. It finds the right transcript even when the meeting never used your exact keyword.
Supermemory searchGrep 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 ReadOpen 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 WriteShown inline so you can tweak before the call, then saved with a date prefix for next time.
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.
Thought attached means save-it mode. Trigger word alone means snapshot mode. When unsure, snapshot and say what was saved.
Claude reasoningIf today's file exists, add to it. If not, start it with a date header. Old entries are never touched.
GlobFix 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.
EditWalk 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 reasoningJust a save confirmation. No echo of the content, no follow-up questions. Staying out of the way is the whole point.
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.
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 GrepParallel, 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 WebSearchEach 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 reasoningWhat we knew, what is new, what it means for us, and what to watch. Internal only, with sensitive call intel walled off.
Claude reasoningA 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.
WriteThe 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.
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 SlackIt 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 reasoningEach 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 reasoningMarkdown is archived. A rich-text copy lands on the desktop so it pastes cleanly into email or Slack with formatting and links intact.
File writeLinkedIn 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.
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 reasoningSearch 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/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 reasoningA 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-checklistPick a variant and refine. For a multi-author campaign, the brief stays put and only the author identity swaps out.
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.
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 GlobA 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.
WebSearchSpread 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 reasoningSaved 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.
WriteThe 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.
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 ReadDecisions, 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 APIToday'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.
EditA 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.
EditNot just the log. Every doc and edit made that day is archived in one commit.
git commit git pushA 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 syncHow the skills, connectors, and memory chain together into a daily workflow.
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.
Pull overnight meeting transcripts. Save relevant ones to Meeting Transcripts/ with date prefix. Memory tracker updated to avoid duplicates.
Supermemory search + project file scan generates a structured brief. Context summary, talking points, open questions – all in one doc.
Content creation for brand page or founder's profile. Supermemory provides context. Humanizer pass strips AI patterns. Iterate until ship-ready.
Internal scan + Supermemory + web search. What's the competitor doing? What's changed? What does it mean for us?
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.
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.
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.
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.
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.
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.
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.
A full rebuild of the public marketing site, plus a layer that auto-generates a page for every place the company serves.
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.
An in-house tool for producing on-brand copy fast, across many formats, for people who do not want to write prompts.
Instead of a spreadsheet emailed around every week, the team opens one hosted dashboard that keeps itself up to date.
A one-evening build to open a role: a job page, an application form, and a quiet test baked into the thank-you page.
For internal documents that should read like a deck but also live at a URL: team principles, all-hands, onboarding.
When a campaign launches, every employee gets a ready-to-post LinkedIn draft written in their own voice.
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.
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.)
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 candidatesEvery 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 textSix 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 leftThe 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.
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.
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.
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.
Free rule-based cuts run before paid AI scoring, which runs before scarce human review.
Each candidate gets one folder with the raw files and a single summary both the human and Claude read.
STATUS blocks sit between fixed markers, so re-running updates in place and never duplicates.
Manual moves save the original verdict next to the new one, so any change is checkable and reversible.
The lens that ranks applications is not the lens that ranks take-homes. Same plumbing, swapped rubric.
Two top-level files record the current state and decisions, so a fresh chat picks up the work cleanly.
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.
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 foldersThe 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.
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 filesBy 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.
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.
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.
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 + verdictsThis 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.
The campaign is built from CSVs and the results come back as CSVs. Plain text the whole team already trusts, both directions.
Each step saves its progress, so a failed video upload only re-runs that step and the script name is the record.
Nothing reaches live spend without a separate, deliberate command. The audit print-out is the line; a human crosses it.
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.
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 dayThose 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.
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.
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 captionThe 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 readThe 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.
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.
All the logins and rate limits live in the pipeline. The dashboard is a static reader you can’t break by sharing the link.
The plain-English call with its reason is the headline. Nobody has to reverse-engineer a rule out of a graph.
The image-reading pass is the costliest part, so its output is cached. Unchanged ads are never described twice.
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.
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.
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.
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 freeOne 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 roundThe 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.
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.
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.
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 adPilots 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.
The clip is pure motion and material. Logo, captions and call to action go on later in editing.
One winning look drops onto many services for free, because the service is just the swapped-in part.
In-pilot, round 2, or rejected, each with a reason. Roadmap and reject log in a single file.
Pick the model that suits each look. The wrong one burns credits and teaches you nothing.
No people, no in-clip branding, no rival names, baked in. The clip can only be what the rules allow.
Round 1 explores. Round 2 doubles down on winners and promotes one parked look each time.
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.
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.
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.
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.
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.
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.
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.
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
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.
While the idea is still moving, editing text is faster than nudging pixels. Polish comes after the capture, not before.
Three or four columns at real phone size on a single page beat one screen per file. You pick by scrolling, not by memory.
Design on the phone you will ship on. It kills the late “this looks weird on mobile” surprise that shrunk desktop mockups bring in.
Colours, fonts, and spacing go into the CSS up front, and the idea moves inside those limits. Different surfaces, different fonts.
Without it, HTML mockups stay mockups. With it, a four-column page becomes a real Figma file everyone can open in their own tool.
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.
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.
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.
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 chartsInputs 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.
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.
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.
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.
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.
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 slideA 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.
Real charts with live data and real tables that anyone can open and question, not pretty screenshots.
Write the arc as prose and grade the deck against it before designing a single page.
Explain, recommend, approve, build, render, check. Small batches make slip-ups easy to spot.
One person’s content is the truth. Other inputs give data or structure only, and made-up prose gets cut.
Exact tokens and a fixed grid, plus the gotchas (the font naming trap and two shadow sources) learned once.
A steady comment count, a fingerprinted master, an untouched original, and a renumber after inserts.
Once it is hand-polished, build new pieces on the side and drop them in, rather than rebuilding the whole.
Build it natively, preview offline, and never round-trip through a cloud editor. A deck instead of a page, same rule.
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.
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.
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 promptPaste 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.
Remove the background so the icon sits on transparency, ready to drop onto any surface in the app without a white box around it.
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 webpThe skill's real value is the seven things it learned not to do, each one paid for by a bad render.
State the requirement and separately ban the failure. On strong-default subjects, either alone is unreliable.
It emits the prompt; other tools and a human do the middle; Claude closes the loop on export.
The skill always reads the same style guide, so the system stays consistent as the icon set grows.
The rules came from generating real icons and seeing what broke, not from theory written up front.