Pumping out 70–100 creative assets every week across 40 landing pages left our marketing operations drowning in Drive chaos and compliance risk. I deployed four custom Claude skills, automated the Asana-to-Linear handoff, and personally ran a 100% human QA check—saving 15 hours of weekly grunt work with zero FDA flags.
In direct-to-consumer telehealth, creative fatigue hits fast. To sustain patient acquisition, marketing must test dozens of fresh hooks every week. But when advertising compounded Glucagon-Like Peptide-1 (GLP-1) medications, a single unapproved weight-loss promise or missing risk disclosure risks severe FDA warning letters and immediate ad account shutdowns.
At a high-growth telehealth startup, a 15-person distributed contractor team pumped out 70 to 100 creative assets every week across video ads, UGC reels, static banners, and responsive landing pages. The creative velocity was high, but the backend operational infrastructure was cracking:
Zero autonomous ad publishing. Every video script, spoken dialogue, on-screen caption, and disclaimer required my personal sign-off.
Seamless migration of 500 active tasks from Linear to Asana with zero missed deadlines and zero downtime across active sprints.
Zero memory-based pricing. All promotional copy, banners, and checkout pages were required to query one master data contract.
Mandatory responsive testing across 6 viewports on 40 actively managed landing pages daily to guarantee legal disclaimers never clipped on mobile.
Audited time measurements per task comparing the legacy manual bottleneck against Karol's single-source automated operating system:
| Operational Phase | Legacy Bottleneck (Baseline) | Engineered Infrastructure (Karol) | Audited Delta |
|---|---|---|---|
| 01. Brief Setup & Folder Provisioning | 30 mins / task (manual folder creation, copying brief templates) | 2 mins / task (pm-asana auto-provisions Drive folders & docs) | -93.3% |
| 02. Pricing Lookup & Copy Verification | 15 mins / asset (Slack pings to finance, checking old landers) | <10 secs (pricing skill queries Master Google Sheet) | -98.9% |
| 03. Creative Asset Hunting & Context | 20 mins / review (searching unmapped Drive, guessing Figma frames) | Instant (google-drive-filer-creatives + Bidirectional cross-links) | -100.0% |
| 04. First-Pass Regulatory Pre-Screening | 4–6 hrs / batch (routine copy queues waiting on legal counsel) | 10 mins / batch (Overhauled Claude regulatory skill pre-screen) | -95.8% |
| 05. Pre-Deployment QA & Sign-Off | 45 mins / page (inconsistent ad-hoc desktop checks, mobile defects) | 12 mins / page (6-viewport responsive matrix + single-source components) | -73.3% |
| Total Weekly Administrative Drag | ~20.5 Hours / Week | ~5.5 Hours / Week | -15.0 hrs/wk |
In healthcare e-commerce, pricing discrepancies are legal liabilities. I established a master pricing Google Sheet as the company-wide contract, built a custom Claude skill to query it, and directed developers to refactor hardcoded landing pages into single-source components.
Instead of allowing copywriters to copy-paste prices from old briefs or developers to hardcode dollar amounts into web templates, the entire organization queried one centralized data contract:
Query the custom pricing Claude skill for instant, 100% accurate ad copy numbers without checking spreadsheets.
Dynamic web pricing blocks across 40 landing pages update simultaneously from a single centralized component.
Brief doc templates automatically embed exact dosage and pricing grids so creative banners match checkout tiers.
Over time, the marketing ecosystem had accumulated over 100 live landing pages with hardcoded pricing, claims, and disclaimers. Whenever prices, patient counters, or claims shifted, updating them required dozens of individual code edits—and inevitable errors.
To eliminate scattered rules and tribal knowledge trapped in people's heads, I established a centralized operational knowledge base that continuously codified production standards for the distributed team:
LP Framework (Long) for TOF/MOF education-heavy funnels and LP Framework (Short) for high-intent BOF funnels). These frameworks established modular section hierarchies, clinical trust sequences, objection-handling blocks, and CTA placements—elevating all net-new landing pages to a consistent conversion and compliance baseline before development.Rather than buying bloated SaaS tools, I built and deployed four dedicated Claude skills that removed friction from daily creative operations—automating live pricing lookups, Asana project provisioning, Drive asset filing, and seamless marketing-to-engineering handoffs.
Real, unvarnished skill definitions deployed inside Claude to eliminate manual folder creation, cross-tool context switching, pricing drift, and marketing-to-engineering handoff friction.
Directly references the live Master Pricing Google Sheet (sanitized token [SECURE_PRICING_MASTER_SHEET_ID]). Enforces queries strictly against the "Overview" tab, respects per-product copy notes, distinguishes full-dose vs. microdose formulations, and ensures copywriters never cite outdated subscription prices.
--- name: pricing description: Use this skill whenever a question involves pricing, plan names, promos, savings, vial counts, billing cadence, or auto-renewal terms for any product (Semaglutide, Tirzepatide, NAD+, or any future product added to the sheet). Trigger on mentions of plan pricing, subscription cost, promo price, monthly cost, 3-month plan, auto-renewal price, or similar - even if the product name isn't explicit. Always fetch live data rather than relying on memory, since prices and promos change. --- # Plans Overview Pricing ## Source of truth Google Sheet: https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit File ID: `[SECURE_PRICING_MASTER_SHEET_ID]` ## Steps 1. **Always fetch live content** of this file before answering — never rely on previously cached or remembered figures. Use the Google Drive read/fetch tool with the File ID above. 2. This file has two tabs: **"Overview"** and **"Comparison"**. ONLY use data from the **"Overview"** tab. Ignore the "Comparison" tab entirely, even if it appears in the fetched content. 3. Within "Overview," treat the per-product plan tables (columns like Plan Name, # Vials/Cycle, Regular Total, Promo Total, Auto-Renewal terms) as the source of truth — **not** the "Quick-Glance Comparison" section at the bottom of the Overview tab, which is a summary and may lag behind the detailed tables. 4. Pay attention to each product's **"COPY NOTES"** section (e.g. which promos are first-time-customer-only, which plans have no regular/crossed- out price, mandatory disclosures like vial strength) and apply those constraints to any copy or answer generated. 5. If a plan type someone asks about doesn't appear in the tables, state clearly that it doesn't currently exist — don't infer or estimate one. 6. **"As low as" / "Starting at" / "From" phrasing:** these always refer to the single lowest number available across ALL plans for that product — including promo prices, not just regular prices. Compare every plan's Regular (per month) AND Promo (per month) figures and use the lowest one found, regardless of whether it comes from a promo or regular column. (Do not exclude promo pricing when computing this figure.) 7. **Full-dose vs. microdose (Semaglutide & Tirzepatide only):** these two products each have a separate "Full-Dose" and "Microdose" table with different pricing. Default to **Full-Dose** pricing unless the user explicitly asks about microdosing, low-dose, or the microdose funnel. Never mix tables — e.g. don't pull a "lowest price" from the microdose table when the product/context is the standard (full-dose) offering. NAD+ has no full-dose/microdose distinction and is unaffected by this rule.
Governs Asana project and task creation for the marketing team. Enforces the single-task Task model across status pipelines. Every deliverable created automatically provisions an identically-named Google Drive folder and brief doc (Template_Creative_Brief_v2.gdoc) and injects bidirectional links into Asana custom fields.
---
name: "pm-asana"
description: "Project Management for Asana — the Marketing Marketing team. Use when the user wants to: create a new Asana project (campaign or evergreen) for Marketing; create one or more tasks in an existing project; set up a full campaign in one go; parse a brain-dump or task list into Asana tasks; promote an item out of the Ideas project into real work; or backfill/create the Google Drive folder and Brief doc for a new or existing Asana task. Every task created by this skill automatically gets a matching Google Drive folder + Brief doc (named identically to the task) created and linked in. Triggers on mentions of Asana projects/tasks, campaigns, flights, briefs, copy, design, video/UGC, filing marketing work, or setting up a task's Drive folder/doc. Always preview the full plan and wait for explicit confirmation before any write."
---
# pm-asana — Project & Task Creator for Asana
Create well-structured projects and tasks in Asana for the Marketing Marketing team. Every deliverable is a **single task** that moves through its lifecycle via the `Task` status pipeline — never split into separate Brief/Copy/Design tasks. Always preview the full plan and wait for explicit confirmation before executing any write.
**Golden rule: never assume, always ask.** Ask every clarifying question needed so that nothing is ambiguous before building the plan. Do not skip questions to save time.
Every task this skill creates also gets a matching **Google Drive folder + Brief doc, created and linked automatically** — see "RULES — Automatic Google Drive folder + doc" below. This always happens; it is not something to ask permission for.
---
## PHASE 1 — Analysis (always run first)
Verify IDs fresh each session (they can change), then fetch current state:
- `asana_typeahead_search(resource_type: "team", query: "Marketing")` → confirm team GID
- `asana_get_projects_for_team(team_gid)` → existing projects, avoid duplicates
- `asana_typeahead_search(resource_type: "project_template", query: "Campaign")` → confirm template GID
- `asana_get_workspace_users` or `asana_typeahead_search(resource_type: "user")` → resolve assignees
- For an existing target project: `asana_get_project(project_id, opt_fields: "name,custom_field_settings.custom_field.name,custom_field_settings.custom_field.gid,custom_field_settings.custom_field.enum_options.name,custom_field_settings.custom_field.enum_options.gid")` and `asana_get_project_sections(project_id)`
Use this to confirm the project exists, suggest the right project, warn about near-duplicate task names, and resolve field/section/assignee GIDs.
---
## PHASE 2 — Determine creation mode
| Mode | Description |
|---|---|
| new project | Create a campaign or evergreen project (preferably from the Campaign template) |
| new task(s) | Add one or more deliverable tasks to an existing project |
| full campaign | New project + its tasks in one go |
| bulk / brain-dump | User pastes an unstructured list; map it to projects + tasks |
| promote idea | Move/recreate an item from the `Ideas` project into a real project |
| Drive backfill | Create the Drive folder + Brief doc for an **existing** task that doesn't have them yet, and link them in |
If the mode is unclear, ask.
---
## PHASE 3 — Clarify before building (NEVER ASSUME, ALWAYS ASK)
Gather **all** information needed so nothing is ambiguous. Do not cap the number of questions, and do not skip ahead because the input "seems detailed enough." If a required value is missing or guessable, ask — do not infer it.
Always confirm, at minimum:
- **Project**: which existing project, or a new one? Campaign or evergreen?
- **Format** of each deliverable (Blog, Email, Landing Page, Static Ad, Video, UGC, Social, Print) — this determines the status path.
- **Product**(s): Semaglutide (GLP-1), Tirzepatide (GLP-1/GIP), NAD+ — can be multiple.
- **Channel**(s): Meta, Google, Pinterest, TikTok, Instagram, Reddit, Email, ManyChat — can be multiple (cross-channel is normal).
- **Discipline**: Paid, Organic, Owned, SEO.
- **Awareness** stage(s) if relevant: TOF (Unaware), TOF (Problem Aware), MOF (Solution Aware), BOF (Product Aware), BOF (Most Aware).
- **Assignee** and **due date** if known.
- **Resources**: which links already exist (Design, Live). 📂 Google Drive and 📋 Brief never need to be asked about — they're always auto-created and auto-linked (see Drive rules below). ✍️ Copy is **never** auto-linked by that automation, even though the auto-created Brief doc's content may double as copy early on — if the Format's template calls for a Copy line, ask for it (or note it'll be added once the Brief doc's content is split out).
Only the team (`Marketing`), the task type (`Task`), and the Drive folder/Brief doc creation are fixed and never need to be asked.
---
## PHASE 4 — Build and preview the plan
Construct the full plan and present it before any write. The layout below is a template — replace every bracketed placeholder with the real value for this request; do not copy the placeholder text literally.
```
📋 PLAN — [short description of what's being created]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
[PROJECT] [project name, per "RULES — Naming convention"] ([new, from Campaign template] OR [existing])
Team: Marketing
[TASK 1] [task name, per "RULES — Naming convention"]
Project: [destination project name]
Format: [one Format value] | Product: [one or more Product values] | Channel: [one or more Channel values]
Discipline: [Discipline value] | Awareness: [Awareness value(s) if relevant, else omit]
Starting status: Brief ToDo (auto via project Rule)
Path: [the status path for this Format — see "RULES — The single-task model & status paths"]
Assignee: [assignee, or "unassigned"] | Due: [date, or "none"]
Drive: will auto-create folder "[task name]" + Brief doc "[task name]" inside it
[TASK 2] [task name, per "RULES — Naming convention"]
[same field lines as above, filled in for this deliverable]
[…repeat one block per deliverable…]
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Note: I set name, description, fields, assignee, due date and dependencies via the
connector. A project Rule auto-converts each new task to Task at Brief ToDo —
no manual type-setting needed. Each task also gets its own Google Drive folder and
Brief doc, created automatically and linked into the task description.
Type "confirm" to create, or tell me what to adjust.
```
Never write before explicit confirmation ("confirm", "yes", "go ahead", "do it", "looks good"). If the user requests changes, update and re-show.
---
## PHASE 5 — Execute
After confirmation:
1. **Project** (if new): preferred path is the user creating it from the **Campaign** template in the Asana UI (one click) so it inherits `Task`, sections, and saved views. If the user wants it automated, `asana_create_project(name, team, default_view: "board", default_access_level)` then attach the five fields — but warn this plain project won't have the template's task type default or views until adjusted.
2. **Tasks**: `asana_create_task` per deliverable with `name`, `html_notes` (resource block first with **linked labels** — see "How the links MUST be written" in Description templates — then body), `project_id`, `custom_fields`, `assignee`, `due_on`, `followers`. At this point 📂 Google Drive (Marketing) and 📋 Brief are still plain unlinked placeholders (their links don't exist yet).
- **Use `project_id` (singular), NOT `projects`.** Passing `projects` is silently ignored — the task gets created with no project (empty `memberships`), which also makes `custom_fields` fail with *"custom field … is not on given object"*. Always `project_id`.
- **`custom_fields` is a JSON string** mapping field GID → option GID (single-select) or array of option GIDs (multi-select). If a create still rejects a field, create the task with `project_id` first, then `asana_update_task` to set `custom_fields` (the task is a project member by then).
3. **Drive folder + Brief doc** (automatic, every task): immediately after each task is created, run the procedure in "RULES — Automatic Google Drive folder + doc" to create the folder + doc and link them into the task via `asana_update_task` on `html_notes`.
4. **Subtasks**: `asana_create_task(parent: <task_gid>, ...)` alone creates a plain subtask with no project membership — use this for pure organizational containers (e.g. a Stage or Funnel task nested under a bigger container) that hold context/verbatim briefs but never carry Format/fields/Task status themselves. **To create a deliverable subtask that also gets the full Task treatment, pass `project_id` in the same call** — `asana_create_task(parent: <task_gid>, project_id: <project_gid>, ...)`. **Confirmed:** this makes the task both a subtask of its parent AND a full member of that project in one call, inheriting the Task Rule and accepting `custom_fields` normally — no extra step needed. Only a subtask created with `parent` alone (no `project_id`) stays outside any project and can't carry a Task status or fields until added to one in the UI. The single-task model still applies either way: most work is one subtask per deliverable, not split into separate Copy/Design tasks. Deliverable subtasks (created with `project_id`) also get their own Drive folder + Brief doc per step 3.
5. **Dependencies** (if any): `asana_set_task_dependencies` / `asana_set_task_dependents`.
**Connector limits — be honest about these in the plan, never fake them:**
- Cannot set the `Task` task type or its status via API (verified: API-created tasks come in as `custom_type: null`). **This is handled automatically by a project Rule** — *"when a task is added to this project → set task type to Task"* — which converts each new task to Task at its first status (`Brief ToDo`). **Confirmed in use: the Rule reliably fires on API-created tasks.** The Rule lives in the **Campaign template**, so every project created from the template inherits it. If a project is ever created WITHOUT the template (e.g. a plain API-created project), it won't have the Rule and tasks will stay plain — recreate the Rule in that project.
- Cannot create a project *from* a template via API (UI only).
- Cannot create sections, statuses, task types, or task templates via API.
- The Brief doc's "Ticket" link is created by uploading HTML content (with a real `<a href>`) and letting Drive convert it to a native Google Doc — do not upload plain text for this, since a raw URL pasted as plain text is not guaranteed to auto-hyperlink. **Confirmed working live** — the resulting Google Doc renders "Ticket" as a real clickable hyperlink.
- The Drive `create_file` tool's own schema marks its `mimeType` field "DEPRECATED — use contentMimeType instead," yet the tool's description also says folders and Google-native docs are created "by setting mime type to `application/vnd.google-apps.folder`/`.document`" with no other field to do that. This skill uses `mimeType` for the target file type (folder/doc) and `contentMimeType` for the uploaded content's format. **Confirmed working** for folder creation, plain-text doc creation, and the `text/html`-with-`<a href>` Ticket-link doc creation.
- The Asana task object's plain `notes` field (returned by the API after a write) always shows resource lines as label-then-raw-URL, even when `html_notes` was sent with proper `<a href>` labels — this is just the API's plain-text mirror of the rich `html_notes`, not a sign the links failed. Check the rendered task in the Asana UI (or trust a successful write) rather than treating the `notes` field's raw-URL appearance as an error.
After creation, report every item created with its Asana URL, and anything that failed and why — including each task's Drive folder link and Brief doc link.
---
## PHASE 6 — Post-run review (after every successful run)
After reporting the created items, always end with a short self-review of how the run went against this skill. The goal is continuous improvement: surface anything that drifted from what the skill describes so it can be fixed before next time.
Check, at minimum:
- **IDs:** did every GID in the REFERENCE section still resolve (team, project, template, fields, option values, Drive root)? Flag any that changed, were missing, or had to be re-fetched.
- **Connector capabilities:** did anything behave differently than the "Connector limits" note claims — e.g. the API now lets you set the task type/status, instantiate a project from a template, create sections, or reliably auto-link URLs inside a Google Doc? Flag new capabilities and newly-broken ones.
- **Fields & options:** did any Format / Product / Channel / Discipline / Awareness value not exist, get renamed, or not apply cleanly?
- **Naming & status paths:** did the naming convention or a Format's status path need a workaround or feel wrong?
- **Drive:** did the project-level Drive folder resolve cleanly for every project used? Any task where no matching project folder could be found (so the Drive step had to be skipped or routed to `_Inbox (ToSort)`)? Any naming mismatch between the created folder/doc and the task name?
- **Ambiguity:** did anything require guessing (a violation of "never assume")? If so, note the question that should have been asked.
- **Anything else** that would make the next run smoother.
Then output exactly one of:
```
✅ No changes needed in skill
```
— or —
```
⚠️ Skill adjustments needed:
- [specific, actionable change #1]
- [specific, actionable change #2]
```
Keep it brief. This review is a recommendation only — never edit the skill automatically; the user decides what to apply.
---
## RULES — Naming convention
Patterns below use bracketed placeholders. Replace each placeholder with the real value; never use the placeholder text itself as a name.
### Projects
- **Campaign:** the campaign's own name only — no product, channel, or date in the name, unless the campaign genuinely recurs (then append the recurring period).
- Pattern: `[campaign name]` — or `[campaign name] [recurring period]` if it repeats.
- **Evergreen:** the plain name of the ongoing production line/function.
- Pattern: `[function name]`
- **Ideas:** the single `💡 Ideas` project. Never put product or channel in a project name — those are fields. This is what prevents project sprawl (do not create one project per channel).
### Tasks
Pattern: `[concept or funnel] - [specific asset]`
- `[concept or funnel]` = the campaign idea, funnel, or theme the deliverable belongs to.
- `[specific asset]` = the exact thing being produced, plus any identifying number/variant.
- Evergreen task with no campaign concept: use just `[descriptor]` (e.g. the topic plus the asset, or a sequence number) — no concept prefix needed.
Rules:
- Separator is ` - ` (space, hyphen, space). Never `|`, `/`, `—`, or `:`.
- **No TYPE prefix** (BRIEF/COPY/DESIGN are retired — task type + Format + status cover this).
- **No channel, product, or format in the title** — those live in fields.
- Title must be readable standalone (in a notification, without the project open).
- **This exact title is also the name of the task's Drive folder and Brief doc** (see Drive rules below) — one more reason it must be exact and final before creating.
### Hard block
If a proposed name doesn't conform, refuse and explain what to change. Never create a non-conforming name "just for now."
---
## RULES — The single-task model & status paths
One deliverable = one task = one `Task`, advancing through statuses. Which statuses a task uses depends on its **Format**:
| Format | Status path |
|---|---|
| Blog · text Social | Brief → Copy → **Copy QA** → Approved → Done *(skip Visual + Final QA)* |
| Email · Landing Page · Static Ad · image Social · Print | Brief → Copy → Copy QA → Visual → Final QA → Approved → Done |
| Video · UGC | Brief → Copy *(script)* → Copy QA *(script compliance)* → Visual *(footage + edit)* → Final QA → Approved → Done |
- `Copy` = the writing phase (copy, or **script** for video). `Visual` = production (design, or footage + edit for video).
- Copy-only formats use **Copy QA** as their single compliance gate and never enter Visual or Final QA.
- Record the intended initial status and full path in the plan, even though the API sets only the default.
---
## RULES — Fields to always set
Set every applicable field on task creation via `custom_fields` (a JSON string of `{ "<fieldGID>": <value> }`). Multi-enum values are **arrays** of option GIDs; single-enum values are a single option GID string.
Always set **Format** (drives the status path). Set **Product**, **Channel**, **Discipline**, and **Awareness** whenever known. Ask if unknown — do not guess.
**Exception — SEO/Blog tasks intentionally leave `Channel` empty** (their home is organic search / the website, which isn't a Channel option; `Discipline = SEO` covers it). Don't flag Channel as missing or ask for it on Blog/SEO work.
---
## RULES — Automatic Google Drive folder + doc
Every task this skill creates (and every task run through "Drive backfill" mode) gets a matching Google Drive folder with a Brief doc inside it, following the same project ↔ Drive mirror described in the `google-drive-filer-creatives` skill: **top-level Drive folder = Asana project name, sub-folder = Asana task name, verbatim.** This is always done automatically — never ask the user whether to do it, only report the result.
Tools used: `search_files` (find the project folder and check for an existing task folder) and `create_file` (create the folder and the doc). Drive root folder ID: `[MARKETING_DRIVE_ROOT_FOLDER_ID]` (same root as `google-drive-filer-creatives`).
### Procedure, per task (run right after the Asana task is created and its `permalink_url`/gid are known)
1. **Resolve the project's Drive folder.** `search_files` with `parentId = '[MARKETING_DRIVE_ROOT_FOLDER_ID]' and mimeType = 'application/vnd.google-apps.folder' and title = '<exact project name>'`. Cache the result per project for the rest of the run (no need to re-search per task in the same project).
- **Not found?** Don't guess or create a new top-level project folder. Tell the user no Drive folder exists for that project, skip the Drive step for its tasks, and leave the 📂/📋 lines as unlinked placeholders per the normal template rule.
2. **Check for an existing task folder** (idempotency, needed for both new-task and Drive-backfill modes): `search_files` with `parentId = '<project folder id>' and mimeType = 'application/vnd.google-apps.folder' and title = '<exact task name>'`.
- **Already exists?** Don't create a duplicate. Use the existing folder. Look inside it (`parentId = '<task folder id>'`) for a doc already named `<exact task name>`; if one exists, use it and don't create a second doc — just make sure both are linked into the Asana task description if they aren't already.
3. **Create the task folder** (only if step 2 found nothing): `create_file(title: "<exact task name>", parentId: "<project folder id>", mimeType: "application/vnd.google-apps.folder")`.
4. **Create the Brief doc** (only if step 2 found nothing): `create_file(title: "<exact task name>", parentId: "<task folder id from step 3>", mimeType: "application/vnd.google-apps.document", textContent: "<h1><exact task name></h1><p><a href=\"<asana task permalink_url>\">Ticket</a></p>", contentMimeType: "text/html")`. **Content must be uploaded as HTML (`contentMimeType: "text/html"`), not plain text** — Drive converts the HTML into a native Google Doc on creation, which is what turns the Asana link into a real clickable hyperlink instead of pasting a raw URL. (Note: `<p>` is fine here — this HTML goes to Drive's own converter, not Asana; Asana's own `<p>` restriction, below, does not apply to this call.) The doc's first line is its own title (as a heading) and the second line is the word **"Ticket"**, hyperlinked to the Asana task's `permalink_url` — never display the raw URL as visible text. This doc is where the brief and/or copywriting for the task lives — one doc serves both purposes unless the team later splits copy into its own doc.
5. **Get shareable links** for the folder and the doc (the file objects returned by `create_file`/`search_files` carry the Drive URL — use it directly; do not construct URLs by hand).
6. **Link into Asana.** Update the task's `html_notes` via `asana_update_task`, replacing the plain-label placeholders with linked labels, per "How the links MUST be written":
- `📂 Google Drive (Marketing)` → the task folder link.
- `📋 Brief` → the Brief doc link.
- Leave every other resource line (`🎨 Design`, `✍️ Copy`/`Script`, `🌐 Live`) exactly as-is — this automation never touches those.
### Notes
- **Names must match exactly, character-for-character** — the Drive folder, the Drive doc, and the Asana task title are always identical. If the task is later renamed in Asana, rename the folder and doc to match (not automatic — flag it if you notice a mismatch).
- **Drive backfill mode** runs the same procedure (steps 1–6) against an existing task: read its current `html_notes`/`notes` first so you don't clobber other resource lines, and skip creation for any folder/doc step 2 finds already exists.
- **Dual-homed tasks** (in two Asana projects, per `google-drive-filer-creatives`) get their Drive folder placed under the more specific/strategic project, same as that skill's rule — don't create a second copy of the folder under the other project.
- **`_`-prefixed shared folders** (`_Asset Library`, `_Brand and Compliance`, etc.) are never a target of this automation — it only ever creates task-named folders inside a project folder.
---
## REFERENCE — Live IDs (verify fresh each session)
```
Workspace (company.com): [WORKSPACE_GID]
Marketing team: [MARKETING_TEAM_GID]
Ideas project: [IDEAS_PROJECT_GID]
Campaign template: [CAMPAIGN_TEMPLATE_GID]
Task type: Task (set in UI; API cannot assign it)
Google Drive root folder: [MARKETING_DRIVE_ROOT_FOLDER_ID]
```
### Custom fields & option GIDs
**Channel** — `[FIELD_GID_CHANNEL]` (multi_enum)
| Option | GID |
|---|---|
| Meta | [GID_CH_META] |
| Google | [GID_CH_GOOGLE] |
| Pinterest | [GID_CH_PINTEREST] |
| TikTok | [GID_CH_TIKTOK] |
| Instagram | [GID_CH_INSTAGRAM] |
| Reddit | [GID_CH_REDDIT] |
| Email | [GID_CH_EMAIL] |
| SMS | [GID_CH_SMS] |
| ManyChat | [GID_CH_MANYCHAT] |
**Product** — `[FIELD_GID_PRODUCT]` (multi_enum)
| Option | GID |
|---|---|
| Semaglutide (GLP-1) | [GID_PROD_SEMA] |
| Tirzepatide (GLP-1/GIP) | [GID_PROD_TIRZ] |
| NAD+ | [GID_PROD_NAD] |
| Sermorelin | [GID_PROD_SERM] |
**Discipline** — `[FIELD_GID_DISCIPLINE]` (enum)
| Option | GID |
|---|---|
| Paid | [GID_DISC_PAID] |
| Organic | [GID_DISC_ORGANIC] |
| Owned | [GID_DISC_OWNED] |
| SEO | [GID_DISC_SEO] |
**Awareness** — `[FIELD_GID_AWARENESS]` (multi_enum)
| Option | GID |
|---|---|
| TOF (Unaware) | [GID_AWR_TOF_UNAWARE] |
| TOF (Problem Aware) | [GID_AWR_TOF_PROBLEM] |
| MOF (Solution Aware) | [GID_AWR_MOF_SOLUTION] |
| BOF (Product Aware) | [GID_AWR_BOF_PRODUCT] |
| BOF (Most Aware) | [GID_AWR_BOF_MOST] |
**Format** — `[FIELD_GID_FORMAT]` (enum)
| Option | GID |
|---|---|
| Blog | [GID_FMT_BLOG] |
| Email | [GID_FMT_EMAIL] |
| Landing Page | [GID_FMT_LP] |
| Static Ad | [GID_FMT_STATIC] |
| Video | [GID_FMT_VIDEO] |
| UGC | [GID_FMT_UGC] |
| Social | [GID_FMT_SOCIAL] |
| Print | [GID_FMT_PRINT] |
> **Print** = offline / physical collateral — handouts, package inserts, flyers, mailers. Route any printed deliverable here. Follows the copy + design status path.
**Example `custom_fields` string** (a Meta+Pinterest, GLP-1, Paid, TOF, Static Ad task):
```
{"[FIELD_GID_FORMAT]":"[GID_FMT_STATIC]","[FIELD_GID_PRODUCT]":["[GID_PROD_SEMA]"],"[FIELD_GID_CHANNEL]":["[GID_CH_META]","[GID_CH_PINTEREST]"],"[FIELD_GID_DISCIPLINE]":"[GID_DISC_PAID]","[FIELD_GID_AWARENESS]":["[GID_AWR_TOF_UNAWARE]"]}
```
### Task status order (for the plan / UI reference)
```
Brief ToDo · Brief In Progress · Brief Done
Copy ToDo · Copy In Progress · Copy In Review · Copy In Adjustment · Copy Done · Copy QA (incl. Compliance)
Visual ToDo · Visual In Progress · Visual In Review · Visual In Adjustment · Visual Done · Final QA (incl. Compliance)
Approved · Done · Canceled
```
---
## Description templates (resource block FIRST)
The clickable resource block goes at the very top so links are reachable the instant a task opens. **Every line the task's Format template calls for is always included — never omit a line just because the destination doesn't exist yet.** Use the ready-made block for that Format (below) exactly as written: drop in a real link wherever a URL is known, and leave every other line as its plain unlinked label. There is nothing to decide or reconstruct per task — copy the block for the Format and go.
**📂 Google Drive (Marketing) and 📋 Brief are populated automatically** by the procedure in "RULES — Automatic Google Drive folder + doc" right after task creation — write the initial `html_notes` with them as plain placeholders (per the templates below), then the Drive step immediately follows up with `asana_update_task` to turn them into real links. Never skip writing the placeholder lines up front just because you know they'll be filled in a moment later.
### How the links MUST be written (do not skip this)
**The label text itself is the hyperlink. The URL is never shown as visible text.**
- ✅ Correct: the words **Google Drive (Marketing)** are clickable and point to the URL.
- ❌ Wrong: `📂 Google Drive (Marketing): https://drive.google.com/...` (raw URL printed next to the label).
- ❌ Wrong: emoji + label as plain text with the link sitting separately.
To achieve this you **must** write the description with the **`html_notes`** parameter (NOT the plain `notes` parameter — plain text only auto-links a raw URL, which is the wrong look). Each resource line is an `<li>` whose emoji is followed by an `<a>` whose *visible text is the label*:
```html
<body>
<ul>
<li>🌐 <a href="https://…">Live</a></li>
<li>📂 <a href="https://drive.google.com/…">Google Drive (Marketing)</a></li>
<li>🎨 <a href="https://figma.com/…">Design</a></li>
<li>✍️ <a href="https://docs.google.com/…">Copy</a></li>
<li>📋 <a href="https://docs.google.com/…">Brief</a></li>
<li>💰 <a href="https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit?gid=[PRICING_TAB_GID]#gid=[PRICING_TAB_GID]">Pricing</a></li>
</ul>
<h2>Objective</h2>
One sentence describing the objective goes here as plain text — do NOT wrap it in a <p> tag.
</body>
```
**Asana `html_notes` is strict XML — follow these rules or the call fails with "XML is invalid":**
- Single root `<body>…</body>`, well-formed and properly closed.
- **Allowed tags only:** `<body> <h1> <h2> <ol> <ul> <li> <strong> <em> <u> <s> <code> <pre> <blockquote> <a> <hr/> <img>`.
- **NOT allowed — confirmed to hard-fail the call with "XML is invalid":** `<p>`, `<br>`/`<br/>`, `<b>`, `<i>`. **Never use `<p>` for body text** (e.g. the sentence under `<h2>Objective</h2>` or `<h2>Details</h2>`) — write that text as a plain text node directly under `<body>`, right after the heading, with no wrapping tag. Use `<ul>/<li>` for the resource list and `<h2>` for section headings; never use `<br/>` for line breaks.
- Only `<a>` may carry attributes (`href`). Any attribute on another element is rejected.
- **Every resource line in the Format's template (see the ready-made blocks below) is always included, on every task of that Format, with no exceptions and no case-by-case judgment calls.** If a URL is known, wrap the label in `<a href="...">`. If not, leave it as plain emoji + label text with no `<a>` wrapping (e.g. `✍️ Copy`, `🌐 Live`) — a visible placeholder ready to become a link the instant the doc/file/page exists. Never omit a template line because "it doesn't exist yet" — that's exactly what the unlinked placeholder is for. The only line that's never left unlinked is 💰 Pricing, since it always has the same fixed, already-known URL. 📂 Google Drive (Marketing) and 📋 Brief are effectively never left unlinked either, since the automatic Drive step fills them in immediately after task creation.
> If you ever fall back to plain `notes` (e.g. no links at all), that's fine for link-free text — but the moment a resource has a URL, use `html_notes` with linked labels.
**FIXED ORDER — do not reorder.** Resource lines must ALWAYS appear top-to-bottom in exactly the order below, no matter which links a task has or what order they appeared in the source. Omit any line that doesn't apply, but never move a line above its position here. (Common mistake to avoid: putting Brief or Copy at the top — Brief is second-to-last, Copy/Script sits above Brief.)
**Resource vocabulary (canonical order — each label is the clickable link):**
```
🌐 Live
📂 Google Drive (Marketing)
🎨 Design
✍️ Copy (or ✍️ Script)
📋 Brief
💰 Pricing → always links to https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit?gid=[PRICING_TAB_GID]#gid=[PRICING_TAB_GID]
```
Each `🔖 Label` below is a **linked label** (emoji + `<a href>` whose visible text is the label) emitted via `html_notes` per the rule above — never a bare URL.
### Blog (Format = Blog)
Use this block verbatim — every line included, unlinked except Pricing:
```html
<ul>
<li>🌐 Live</li>
<li>📂 Google Drive (Marketing)</li>
<li>✍️ Copy</li>
<li>📋 Brief</li>
<li>💰 <a href="https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit?gid=[PRICING_TAB_GID]#gid=[PRICING_TAB_GID]">Pricing</a></li>
</ul>
```
Follow with `<h2>Objective</h2>` (one sentence, as a plain text node — no `<p>` — describing what this article is and the search/topic goal) then `<h2>Details</h2>` (more detail if available, also plain text). As each destination is created, replace that line's plain label with `<a href="...">label</a>` — the rest of the block doesn't change.
### Copy + Design (Format = Email / Landing Page / Static Ad / image Social / Print)
Use this block verbatim — every line included, unlinked except Pricing:
```html
<ul>
<li>🌐 Live</li>
<li>📂 Google Drive (Marketing)</li>
<li>🎨 Design</li>
<li>✍️ Copy</li>
<li>📋 Brief</li>
<li>💰 <a href="https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit?gid=[PRICING_TAB_GID]#gid=[PRICING_TAB_GID]">Pricing</a></li>
</ul>
```
Follow with `<h2>Objective</h2>` (one sentence, as a plain text node — no `<p>` — describing what this asset is and why it exists) then `<h2>Details</h2>` (more detail if available, also plain text). Link each label in-place as its destination is created.
**Special case — Landing Page framework reference:** When Format = Landing Page, add a line in `<h2>Details</h2>` (not the resource block — the right link depends on the Awareness field, which is multi-select, so picking it can need a judgment call rather than being a clean always-linkable resource) pointing to the matching framework:
- Awareness includes TOF and/or MOF → link 💻 [LP Framework (Long)](https://app.notion.com/p/[SECURE_NOTION_LP_FRAMEWORK_LONG_ID])
- Awareness is BOF only → link 💻 [LP Framework (Short)](https://app.notion.com/p/[SECURE_NOTION_LP_FRAMEWORK_SHORT_ID])
- If Awareness spans both TOF/MOF and BOF, default to the Long framework (it covers more ground) and note why in Details.
### Video / UGC (Format = Video / UGC)
Use this block verbatim — every line included, unlinked except Pricing:
```html
<ul>
<li>📂 Google Drive (Marketing)</li>
<li>✍️ Script</li>
<li>📋 Brief</li>
<li>💰 <a href="https://docs.google.com/spreadsheets/d/[SECURE_PRICING_MASTER_SHEET_ID]/edit?gid=[PRICING_TAB_GID]#gid=[PRICING_TAB_GID]">Pricing</a></li>
</ul>
```
Follow with `<h2>Objective</h2>` (one sentence, as a plain text node — no `<p>` — describing what this video is and the platform/placement) then `<h2>More Details</h2>` (more detail if available, also plain text). Link each label in-place as its destination is created.
---
## Bulk / brain-dump mode
1. Read the full input; identify every distinct deliverable.
2. Map each to a project + a single task with a conforming name and a Format.
3. Flag anything ambiguous with ❓ and ask before executing (never assume).
4. Present the complete plan in the Phase 4 format; wait for confirmation.
### Example for flaging ambiguous request
```
❓ UNCLEAR: "redo the landing page"
→ Which product? Which channel? Which campaign/project? (Format = Landing Page assumed — confirm.)
```
---
## Promote-from-Ideas mode
When an item in `💡 Ideas` is greenlit:
1. Read the idea task.
2. Confirm its destination (existing project or a new one) and all required fields.
3. Recreate it as a conforming task in the destination (or move it), carrying over resources.
4. Mark the original Ideas task `Done`/`Canceled` or note the move. Confirm before writing.
5. Create its Drive folder + Brief doc per "RULES — Automatic Google Drive folder + doc" in the destination project, same as any new task.
---
## Drive backfill mode
For an existing task that's missing its Drive folder/doc, or where the user pastes an Asana task link and asks for its Drive resources to be set up:
1. Fetch the task (`asana_get_task`) — get its exact name, project, and current `html_notes`/`notes`.
2. Run the procedure in "RULES — Automatic Google Drive folder + doc," steps 1–6, against that task.
3. Report the folder/doc links created (or reused, if they already existed).
No confirmation step is required for backfill mode beyond the user's original request — it never touches Asana fields, status, or any resource line other than 📂 Google Drive (Marketing) and 📋 Brief.
---
## Things to never do
- Never create a task or project before explicit confirmation.
- Never split one deliverable into separate Brief/Copy/Design tasks — it's one `Task`.
- Never put product, channel, or format in a project or task title — those are fields.
- Never use a TYPE prefix (BRIEF/COPY/DESIGN) in a title — retired.
- Never guess a Format, product, channel, or assignee — ask.
- Never claim the *connector* set the task type/status — the API can't; it's the project Rule that converts new tasks to Task.
- Never recreate the retired Linear labels (Type:*, Operational:*).
- Never create a campaign project per channel (no "Meta Ads" project) — channel is a field.
- Never create a duplicate Drive folder or doc for a task that already has one — always check first (see "RULES — Automatic Google Drive folder + doc," step 2).
- Never let the Drive folder/doc name drift from the exact Asana task title.
- Never skip the automatic Drive step or ask permission to run it — it always runs for every task this skill creates.
- **Never use `<p>` inside an Asana `html_notes` payload** — it hard-fails the call with "XML is invalid." Body text goes as a plain text node under `<body>`, not wrapped in `<p>`.
Organizes the shared marketing Drive to mirror Asana 1:1 (Asana project → Asana task → identically named Drive folder). Enables contractors to instantly find assets, routes new uploads to _Asset Library or task folders, and handles cross-folder gathering.
--- name: google-drive-filer-creatives description: >- THE default for any question about where a Marketing marketing file or folder lives in the shared Google Drive, where to put a new one, or requests to gather every file of a type from a time window across the Drive (e.g. "all static ads from the past 2 weeks," "every UGC video from last quarter"). Trigger on casual asks like "where is the brand kit?", "where do logos/fonts live?", "which folder has the Pinterest ads?", "where is the pricing sheet?" — and on cross-folder gathering requests even without a named project. The Drive mirrors Asana 1:1 (project = top folder, task = sub-folder, same names). Use for finding, saving, filing, or gathering any marketing asset: ads, LPs, UGC/video, blog articles, email/SMS, briefs, brand kit, logos, fonts, FDA/COA docs, NDAs, voice-overs, testimonials, funnels, pricing sheet. Lean toward using it, even for one-liners. Do NOT use only to write/generate content, create Asana tasks, review compliance, or look up live pricing. Work from the live Drive, not memory. --- # Marketing Google Drive Filer Three jobs, all grounded in the same mental model of the Drive: (1) **find** where an existing file lives, (2) **place** a new file so it lands in the correct folder, and (3) **gather** every file of a type from a time window, scattered across many folders. Jobs 1 and 2 are the common case and are fully covered below. Job 3 is a heavier crawl-based job — read its reference file before starting one. ## The model (how the Drive is organized) - **Top level = Asana projects.** Each Asana marketing project has one Drive folder with the exact same name, plus a few shared support folders whose names start with `_`. - **Inside a project = folders named exactly like Asana tasks**, flat (no channel/status sub-layers). A task folder holds everything for that task. - **`_`-prefixed folders are the exceptions** — standing/shared material that isn't a single task. - So the path to anything is: **Asana project → Asana task → the identically-named Drive folder.** You reason from Asana; the Drive mirrors it. There is a root README titled **"Where are my files?"** that explains the whole system — point people to it for the full picture. For the full top-level folder list and the less-common edge-case rules (funnels, testimonial-style ads, Agency, file naming, etc.), see `references/drive-map.md` — read it whenever a Job 2 placement touches one of those cases, or whenever you need exact folder names beyond what's inline here. ## Always work from the LIVE Drive — do not rely on a memorized tree The structure changes as projects and tasks are added, and folders are renamed to match Asana. **Never answer from a static map.** This applies to all three jobs. When the Google Drive connector is available: 1. Start at the **root folder** `[MARKETING_DRIVE_ROOT_FOLDER_ID]` and list children with a `parentId = '<id>'` search. 2. Drill into the relevant project folder to read the **current** task-named folders and grab the **live folder link**. 3. When looking for something by name, search `title contains '...'`. Return live links, never guessed ones. If the connector isn't available, say so and use the reference list in `references/drive-map.md` as a fallback (note it may be out of date). ## Job 1 — Finding a file 1. Work out which **Asana project + task** it belongs to (ask if genuinely unclear). 2. In the live Drive, open that project folder and find the task-named folder; or search by title if you're not sure of the project. 3. Reply with the folder (or file) and its live link. If it isn't where it should be, check `_Inbox (ToSort)` and `_Archive`, and say so. ## Job 2 — Placing a file (decision logic, in order) 1. **Reusable media** not tied to one campaign (b-roll, stock imagery, voice-over, end cards, GIFs)? → **`_Asset Library`** (matching subfolder). 2. **Evergreen brand / legal / compliance / reference** (brand kit, logos, fonts, FDA docs, COAs, NDAs & release forms, playbooks, personas, naming conventions, the company pricing sheet)? → **`_Brand and Compliance`** (Brand Kit / FDA and Compliance / Reference Materials / Legal and Agreements). 3. **Otherwise it belongs to a specific Asana task** → its **project folder** → a folder **named exactly like the task**. If that folder doesn't exist yet, tell the user to create it (name = the task, verbatim) and paste the folder link onto the Asana task. 4. **Match the folder name to the Asana task exactly** (character-for-character). 5. **Dual-homed task** (in two Asana projects) → it lives under the **more specific / strategic** project; the other project reaches it via the Asana task link. (E.g., an email+retention task → Retention; an email+portal task → Patient Portal.) 6. **Can't determine confidently?** → route to **`_Inbox (ToSort)`** and say what extra info would place it. Several categories have their own filing quirks — funnels, testimonials vs. testimonial-*style* ads, content-library projects (Blog Articles, Social Media), Agency, and file-naming conventions. These are common enough to get wrong that they're worth checking: see `references/drive-map.md` before you finalize a Job 2 placement that touches any of those. ## Job 3 — Gathering many files across the Drive Different shape of request: "give me every [static ad / UGC video] from the last N [days/weeks/ months]," "pull the video assets we shipped this quarter," "show me recent ad creative across projects." Unlike Jobs 1–2, you don't know roughly where the files are — there's no folder that collects "all static ads" across projects, so this requires crawling the Drive tree rather than a single search. Before starting one of these, read `references/cross-folder-listing.md` in full — it covers how to scope the ask (asset type + time window, optionally narrowed to a named project), how to walk the tree without missing subfolders, which folders to skip by design, and the folder-level report format the user expects back. Don't improvise a crawl from the model above; the reference file has the mimeType/createdTime filters and exclusion list you need to get it right. ## Reply format (Jobs 1–2) Keep it short — a destination (or location) and a link, not an essay: > **Put it in / Find it in:** `<full folder path>` > **Link:** <live Drive link> > **Why:** <one sentence> > *(If unsure)* **Or:** `<alternative path>` — <one sentence> If a file should be split, archived, or doesn't belong in the marketing Drive, say so plainly. If two projects genuinely fit, ask which Asana task/project it's for rather than guessing. (Job 3 has its own folder-level report format — see `references/cross-folder-listing.md`.)
Turns finished Asana marketing tasks into complete, self-contained Linear engineering tickets. Automatically extracts the Figma design link (<a href="...">Design</a>), linked Brief and Copy docs from Drive, CTA forward destinations, and quiz calculation logic so developers never need to ask back.
---
name: linear-dev-handoff
description: "Create a Linear Engineering issue from a finished Marketing Marketing Asana task that's ready to hand off to dev. Use this skill whenever the user gives an Asana task link and says it's done/ready for dev, ready for engineering, needs a dev ticket, or wants to hand something off to engineering — even if they don't say 'Linear' by name. Also trigger on phrases like 'file this for eng', 'create the dev ticket for this', 'send this to engineering', or pasting an Asana task URL alongside any request to start engineering work. Pulls the Figma design link, campaign context, CTA destinations, and any quiz/calculation logic out of the Asana task (from its description or linked docs) so the Linear issue is self-contained and engineering never has to come back and ask for more information."
---
# linear-dev-handoff — Asana → Linear Dev Ticket Creator
Turn a finished Marketing Marketing Asana task into a single, self-contained Linear issue for
the Engineering team. The whole point of this skill is that engineering should be able to pick
up the Linear issue and build without pinging anyone — so the real work here is *reading the
Asana task carefully and completely*, not just copying a link across.
**Golden rule: if something a developer would need isn't on the Asana task, ask the user for it
— never invent it, and never ship the issue with a gap.**
---
## PHASE 1 — Pull the Asana task
The user will give you an Asana task URL. Extract the task GID from it and fetch the full task:
```
asana_get_task(task_id, opt_fields: "name,notes,html_notes,permalink_url,projects.name,projects.gid,custom_fields.name,custom_fields.display_value")
```
You need `html_notes` specifically (not just `notes`) because the resource block — where the
Figma link lives — is written as an `<a href>` inside a `<ul>`, which only shows up in
`html_notes`.
Note which project(s) the task belongs to (`Ads + LPs`, `Email Marketing`, `Website`, or
something else) — this determines what extra content you need to go find in Phase 3.
---
## PHASE 2 — Find the Figma link
The Design link lives on the 🎨 line of the task's resource block, e.g.:
```html
<li>🎨 <a href="https://figma.com/...">Design</a></li>
```
Parse `html_notes` for this line and pull the href. Two fallbacks, in order:
1. If the resource block exists but 🎨 Design has no link yet (still a bare, unlinked label),
stop and ask the user for the Figma link — don't guess and don't proceed without it.
2. If there's no resource block at all (task wasn't built from the usual template), scan the
full description for any `figma.com` URL. If you still can't find one, ask.
Only the link itself is needed in the Linear issue — never pull actual frames/screenshots out
of Figma for this. Engineering opens Figma directly; over-fetching design content just adds
noise.
---
## PHASE 3 — Gather the context engineering needs, by project
| Asana project | What the Linear description needs |
|---|---|
| **Ads + LPs** | Figma link + why this was built: campaign/channel context and the goal, pulled from the description **and** the linked Brief/Copy doc |
| **Website** | Same as Ads + LPs — Figma link + campaign/channel context and the goal, from the description **and** the linked Brief/Copy doc |
| **Email Marketing** | Figma link + context/goal (same sources) + **where every CTA forwards to** + **any quiz/calculation logic** |
| Anything else | Whatever the task actually contains that engineering would need — use judgment. This mapping is new and will likely need a project-specific row added later; if you hit an unfamiliar project, say so and ask the user what engineering needs for it, rather than silently improvising a format. |
**Context/goal** (all projects): don't stop at the description. Pull the initial context from the
free-text part of the description — usually under an `Objective` or `Details` heading, outside
the resource `<ul>` — but then also **open whichever doc is linked from the resource block (📋
Brief, then ✍️ Copy)** and pull in anything there that adds to the picture: the actual campaign
rationale, target audience, key message, etc. often lives in the Brief doc rather than the Asana
description itself, which is frequently just a short pointer to it. Combine both sources into
one coherent `Context` section — don't make engineering open the Brief doc themselves to
understand what they're building. Carry the actual substance across, not just a one-line label.
**CTA destinations** (Email Marketing only): check the description text first. If it's not
there, it's most commonly written inside whichever doc is linked from the resource block
(📋 Brief or ✍️ Copy) — read that doc. If you can't find CTA destinations anywhere, ask the user
rather than leaving it out — a Linear issue for an email/LP without CTA targets is exactly the
kind of gap that causes back-and-forth.
**Quiz/calculation logic** (Email Marketing, when relevant — not every task has this): check in
this order:
1. The task description itself.
2. The linked Brief doc (📋), then the linked Copy doc (✍️) from the resource block — this is
the most common home for it.
3. If genuinely not found anywhere and the task clearly involves a quiz or calculated result,
ask the user for it or for a link to it. Don't skip this silently — either include the actual
logic inline, or a working link to the doc that has it. A vague "see design" is not enough.
To read a linked Google Doc, use the Drive connector's `read_file_content` against the doc's
file ID (extract it from the Drive URL).
---
## PHASE 4 — Ask for the due date
Due date is never inferred — always ask the user directly, e.g. "What due date should I set on
the Linear issue?" Accept whatever they say. If they say there isn't one ("none", "no rush", "no
due date"), just leave the Linear issue's due date empty — don't push back on this.
---
## PHASE 5 — Build the Linear issue description
**Title**: mirror the Asana task's name exactly. No prefix, no reformatting.
**Description** (Markdown, passed to `save_issue`'s `description` field): start with the
resource links, then the sections that apply for this project, then the subscriber mention at
the very end so it doesn't interrupt the technical content:
```markdown
🧑💻 [Asana Ticket](<asana permalink_url>)
🎨 [Figma Design](<figma url>)
## Context
<why this was built — campaign/channel and the goal, in your own words based on the task>
## CTA destinations
<Email Marketing only — one line per CTA, e.g. "Primary CTA → /checkout?plan=monthly". Omit this
whole section for other projects.>
## Calculation logic
<Email Marketing only, and only when the task involves a quiz/calculated result. Either the
logic itself, or a working link to the doc that has it, e.g. 🧮 [Calculation Logic](<doc url>).
Omit entirely if not applicable.>
## What to build
<concrete description of the deliverable, drawn from the Asana task's title and notes — enough
that someone who has never seen the campaign could start work>
---
cc @lead-engineer
```
The `@lead-engineer` mention is how subscription actually works here — Linear's connector has no
direct "add subscriber" field, but @-mentioning a user in the description auto-subscribes them.
Leave it as its own line at the bottom so it reads as a notification, not part of the spec.
Drop any section that doesn't apply (don't leave empty headings). For an unfamiliar project
(Phase 3's "anything else" row), use `Context` + `What to build` as the baseline and add whatever
else the user told you was needed.
---
## PHASE 6 — Preview, then confirm
Before creating or changing anything, show the user:
```
📋 PLAN
[LINEAR ISSUE] <title>
Team: Engineering | Status: Todo | Assignee: lead-dev@company.com
Due: <date, or "none">
── description preview ──
<the full description you built in Phase 5>
[ASANA UPDATE] Adding 🧑💻 Linear Ticket link to the top of the resource block
(link filled in once the Linear issue exists)
Type "confirm" to create it, or tell me what to change.
```
Wait for explicit confirmation before writing anything. If the user asks for changes, update and
re-show.
---
## PHASE 7 — Execute
1. **Create the Linear issue**:
```
save_issue(
team: "[ENGINEERING_TEAM_UUID]", # Engineering
title: <asana task name, verbatim>,
description: <markdown from Phase 5>,
state: "[TODO_STATE_UUID]", # Todo
assignee: "lead-dev@company.com",
dueDate: <ISO date, or omit entirely if none given>
)
```
Leave every other field untouched — no priority, no labels, no Linear project/milestone, no
cycle, no estimate. The user was explicit that everything beyond what's listed above stays
empty.
2. **Write the Linear link back onto the Asana task.** Fetch the task's current `html_notes`,
insert a new first line at the very top of the resource `<ul>` (above 🌐 Live — this line
always goes first, before anything else in the block):
```html
<li>🧑💻 <a href="<linear issue url>">Linear Ticket</a></li>
```
then `asana_update_task(task_id, html_notes: <full reconstructed html_notes>)`. Keep every
other line in the resource block exactly as it was — this is an insert, not a rewrite.
Remember `html_notes` is strict XML: single root `<body>`, only the allowed tags, and only
`<a>` may carry attributes.
---
## PHASE 8 — Report back
Give the user both links:
- The new Linear issue URL
- Confirmation that the Asana task now links to it
If anything had to be asked for in Phase 2–3 (missing Figma link, missing CTA destinations,
missing calc logic, or an unfamiliar project), call that out explicitly in the summary so the
user knows it's a genuine gap in the Asana task, not something you skipped.
---
## Reference — fixed values (verify if a call ever fails; these can change)
```
Linear team (Engineering): [ENGINEERING_TEAM_UUID] (key: COC)
Linear status "Todo": [TODO_STATE_UUID]
Assignee (lead-dev): [LEAD_DEV_UUID]
Subscriber mention (lead-engineer): @lead-engineer (displayName — mention in description, not a field)
```
Asana projects checked and confirmed to share the same 5 custom fields (Channel, Discipline,
Awareness, Product, Format) — none of them carry Figma/CTA/calc-logic as a structured field, so
all of that always comes from reading the description and linked docs, never from custom fields:
`Ads + LPs`, `Email Marketing`, `Website`.
Asana resource block — fixed order, this skill's line always goes first:
```
🧑💻 Linear Ticket ← this skill adds this, always at the top
🌐 Live
📂 Google Drive (Agency)
📂 Google Drive (Marketing)
🎨 Design
✍️ Copy (or Script)
📋 Brief
💰 Pricing ← always last
```
---
## Things to never do
- Never create the Linear issue or edit the Asana task before the user confirms the plan.
- Never invent a Figma link, CTA destination, or calculation logic that isn't actually on the
task or its linked docs — ask instead.
- Never set priority, labels, a Linear project/milestone, cycle, or estimate — those stay empty.
- Never rewrite the Asana resource block wholesale — only insert the new Linear Ticket line and
leave every other line untouched.
- Never pull Figma frames/screenshots into the issue — the link is enough.
Eliminated context switching and asset-hunting across the 15-person distributed team by enforcing a strict bidirectional linking contract:
Every section frame and artboard contains embedded links jumping directly to the corresponding Asana task and Drive asset folder.
Custom fields store one-click links to the exact Figma frame, the prepped brief doc, and the finalized Drive export folder.
Consolidated reusable UI clusters (headers, testimonials, trust seals) on a master page so designers stopped searching 20+ files.
In regulated operations, applied AI must have clear boundaries. We maximized automation for admin scaffolding while locking down critical legal decisions with 100% human oversight:
pm-asana automatically provisions Google Drive folders and brief docs in <2 seconds.pricing queries live figures from the Master Sheet to draft ad copy with zero manual searching.linear-dev-handoff extracts Figma URLs, briefs, and quiz logic into self-contained Linear issues.google-drive-filer-creatives routes files to exact project folders based on the Asana mirror model.While Claude skills automated initial pre-screening and handoffs, I personally served as the sole quality gatekeeper reviewing 70–100 assets per week. Concurrently, I orchestrated a zero-downtime migration of 500 active tasks from Linear to Asana.
Distributed contractor completes initial creative draft using master pricing and brief guidelines.
Automated first-line filter scans copy for unapproved medical claims, missing disclaimers, or invalid pricing.
Comprehensive manual review: spoken audio, video captions, disclaimer legibility, and pricing accuracy.
Systematic responsive testing across 3 desktop and 3 mobile viewports covering 40 actively managed landing pages daily.
Formal stamp of approval. Asset moved to approved production directory and staged for ad launch.
Clear, deterministic rejection criteria applied during personal QA runs to ensure zero compliance leaks reached live ad platforms:
| Category | Defect / Rejection Trigger | Remediation Action Required | Baseline Frequency |
|---|---|---|---|
| Healthcare Regulatory | UGC creator states: "I dropped 15 lbs in 3 weeks without dieting." | Immediate Rejection. Re-cut or re-shoot video. Strict rule: no specific poundage claims tied to unrealistic timeframes. | ~12% of drafts |
| Disclaimer Legibility | Static banner renders compounding disclosure with low color contrast (<4.5:1 ratio). | Design Revision. Add high-contrast backdrop or adjust font color to satisfy accessibility and legal legibility standards. | ~15% of drafts |
| Pricing Drift | Copy lists Semaglutide at "$179 Month 1" based on old promotional material. | Copy Revision. Run through pricing; correct price to $199 per live Master Pricing Sheet. |
0% (post-skill) |
| Caption / Audio Drift | Video subtitles state "FDA-approved GLP-1" while voiceover says "Compounded GLP-1." | Subtitle Correction. Compounded drugs are not FDA-approved; subtitles must match exact legal compounding wording. | ~8% of videos |
| Mobile Clipping | Checkout CTA button or dosage selector clips off-screen on iPhone SE (375px viewport). | Front-End Fix. Adjust CSS flexbox wrap and padding to ensure 100% responsive tap target visibility. | ~10% of pages |
Because over 75% of patient acquisition traffic originates on mobile devices, every landing page update was tested across 6 standardized viewports daily:
Wide-screen monitors. Verifies multi-column comparison grids, hero margins, and high-res imagery.
Standard laptop baseline. Verifies navigation bars, sticky header triggers, and CTA button placement.
Small laptops / tablet landscape. Ensures graceful grid wrapping without horizontal scroll overflow.
Flagship smartphones (iPhone Pro Max, Android). Confirms sticky checkout footers and font scaling.
Core consumer mobile baseline (iPhone 14/15/16). Ensures tap targets exceed 44x44px and forms render smoothly.
Compact mobile stress-test (iPhone SE). Guarantees legal footnotes and medication disclaimers never clip.
When leadership mandated migrating the marketing operations from Linear to Asana to support visual Kanban boards and custom client approvals, dropping deliverables or delaying active ad launches was not an option:
MIGRATED TO ASANA) containing direct hyperlinks jumping to the active Asana counterpart.Engineering high-velocity operations is about making intentional compromises. Below is the diagnostic matrix evaluating the technical and architectural decisions made across the telehealth marketing pipeline.
Why Chosen: Deployed in 2 hours with zero software licensing costs. Allowed instant natural-language querying via Claude without forcing contractors to learn enterprise software.
Trade-Off Accepted: Required strict cell-locking, version protection, and read-only access for contractors to prevent accidental schema corruption, routing all structural catalog updates through Ops.
Why Chosen: In telehealth, an FDA warning letter destroys patient trust and shuts down payment gateways. AI cannot reliably detect subtle spoken sarcasm or evaluate medical tone.
Trade-Off Accepted: Karol remained a personal QA review bottleneck (70–100 assets/week), requiring structured daily time blocks to prevent launch delays.
Why Chosen: Embedded hyperlinks across Figma, Asana, and Drive eliminated 20 minutes of asset-hunting per review and stopped creative briefs from getting lost in Slack threads.
Trade-Off Accepted: Karol personally executed task creation and Drive provisioning via pm-asana for every deliverable rather than delegating unvetted task creation to contractors, guaranteeing 100% linking schema adherence.
Why Chosen: Centralized recurring data components across 40 actively managed landing pages (audited from 100 live pages) so pricing, customer milestone counters ("Over 25,000 patients served"), review tallies, and legal disclaimers updated once in master code and propagated across all live landers simultaneously.
Trade-Off Accepted: Demanded an intensive upfront engineering collaboration to refactor legacy code across 40 pages and decommission 60 stale pages before operational savings materialized.
Why Chosen: Overhauling the stale regulatory skill enabled copywriters to catch 95% of basic compliance errors in seconds, saving expensive legal hours for novel campaign angles.
Trade-Off Accepted: Required ongoing system prompt maintenance whenever FDA compounding policy or state telehealth regulations shifted.
Why Chosen: Asana provided visual Kanban approval stages and contractor guest permissions, while linear-dev-handoff kept engineering cleanly in Linear.
Trade-Off Accepted: Required an upfront 5-week operational runway cleaning Drive taxonomy and standardizing pricing before migrating 500 active tasks, ensuring a pristine target environment rather than rushing a cutover.
Reflections from the operations front lines on scaling creative throughput, deploying applied AI, and building resilient systems in heavily regulated environments.
The most common mistake in marketing ops is trying to automate a mess. If I had built Claude skills on top of the chaotic Google Drive and conflicting spreadsheets, the AI would have accelerated the chaos—hallucinating wrong prices and pointing creators to outdated asset folders. Cleaning the Drive taxonomy, setting up the Master Pricing Sheet, and centralizing web components was the unglamorous groundwork that made the AI skills work deterministically.
Distributed freelance contractors work across multiple client accounts. If you hand them a 40-page PDF of compliance rules, they won't read it. By embedding the rules into an updated Claude skill, cross-linking Figma frames directly to Drive assets, and auto-provisioning folders in Asana via pm-asana, compliance became invisible. When doing things the right way is faster and easier than taking shortcuts, error rates drop to zero naturally.
In regulated industries like telehealth, full AI autonomy is a disaster waiting to happen. The true leverage of applied AI is not replacing human judgment—it is stripping away the 15 hours of repetitive administrative sludge surrounding human judgment. By letting Claude handle folder provisioning, brief formatting, pricing retrieval, and dev ticket compilation, I could dedicate my full cognitive focus to what really mattered: listening to spoken UGC dialogue, auditing captions, and ensuring zero legal violations slipped into the wild across 70–100 assets a week.