The 9 Triangles Framework — The Marketing Strategy Behind Scalable Home Service Businesses

START

---
name: content-strategy-90-greatest-hits-10-new
description: Allocate 90% of content and promotion effort to proven greatest hits and 10% to new experiments, so budget follows evidence instead of novelty.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Content Strategy (90% Greatest Hits, 10% New)

**Use this when** the team keeps producing brand-new content while proven winners sit unpromoted — or when planning any content/ad calendar.

## Inputs
- Performance data for existing content: engagement, watch time, rankings, conversions
- The full content inventory (videos, posts, articles, ads) with metrics attached
- Next period's content/promotion calendar and budget

## Steps
1. Define the split: **90%** of effort goes to greatest hits — content already proven by engagement, rankings, or conversions; **10%** goes to new experiments that might become future hits.
2. Rank the content inventory by real signals (engagement rate, watch time, shares, organic rankings, leads) and mark the top performers as the greatest-hits pool.
3. Spend the 90%: re-boost winners (see /dad), repurpose them into new formats through the Content Factory (/content-factory), refresh and enhance the existing articles on the SEO Tree (/seo-tree) instead of writing thin new ones.
4. Spend the 10%: schedule a small, fixed slice of net-new topics — pulled from the Topic Wheel — as deliberate experiments with $1/day-scale stakes.
5. Promote graduates: when an experiment outperforms the pool median, move it into the greatest-hits pool and give it 90%-tier distribution.
6. Measure it: in the monthly review, check the actual effort/budget split and compare results of hits vs experiments in the MAA report; drift toward 50/50 means the rule has broken.

## Definition of done (QA checklist)
- [ ] Greatest-hits pool documented with the metric evidence for each piece
- [ ] Next period's calendar shows roughly 90/10 effort and budget allocation
- [ ] Every greatest hit has an active distribution action (boost, repurpose, or refresh)
- [ ] Experiments are capped, tracked, and reviewed for promotion into the pool
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) re-ranks the entire content inventory by real signals each cycle and loops until the Definition of done fully passes — pool documented with evidence, calendar at roughly 90/10, every greatest hit carrying an active distribution action — not a partial pass.
It self-verifies by recomputing the actual effort/budget split from the calendar and flagging any drift toward 50/50 before the period starts.
Memory turns the monthly review into a true MAA memory cycle: the agent compares hit-vs-experiment results against prior periods, promotes graduates that beat the pool median, and logs a meta-article example each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: kill-underperformers-scale-winners, use-for-content-planning-and-video-topics, /dad, /content-factory, /seo-tree

END

START

---
name: funnel-levels-audience-engagement-conversion
description: Map every marketing activity into the three funnel levels — Audience, Engagement, Conversion — so each campaign, post, and metric is judged at the stage it actually serves.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Funnel levels (Audience, Engagement, Conversion)

**Use this when** campaigns or content are being judged by the wrong numbers — e.g., demanding sales from a cold-audience video — and you need every activity mapped to its funnel stage.

## Inputs
- Inventory of all active marketing: campaigns, boosted posts, content, email
- Access to platform metrics (reach, engagement, conversion events)
- Goals and target CPA/ROAS from the GCT triangle (the Goals corner)

## Steps
1. Define the three levels: **Audience** (cold reach — people who don't know you yet), **Engagement** (warm — they watch, click, comment, follow), **Conversion** (they opt in, book, or buy).
2. List every active campaign, post, and page, and assign each to exactly one level based on the job it does, not the result you wish it produced.
3. Assign the right primary metric per level: Audience = reach/CPM and video views; Engagement = engagement rate and watch time; Conversion = leads, CPA, ROAS.
4. Check coverage: if any level is empty, the funnel leaks — cold traffic with no warm follow-up, or conversion asks with no audience feeding them.
5. Sequence content cold → warm → conversion so each level feeds the next (see /dad for audience sequencing mechanics).
6. Measure it: report performance level-by-level in the weekly MAA report instead of one blended number, and re-map the inventory monthly.

## Definition of done (QA checklist)
- [ ] Every active campaign and content piece assigned to exactly one funnel level
- [ ] Each level has a named primary metric and a current baseline
- [ ] No empty level — or a documented plan to fill it
- [ ] Weekly MAA report shows performance per level, not blended
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) re-inventories every active campaign, post, and page each cycle and loops until the Definition of done fully passes — every asset mapped to exactly one level with a named metric and baseline, and no empty level without a documented fill plan.
It self-verifies by cross-checking the map against the platforms' active-campaign lists so nothing running goes unassigned.
With memory across runs it holds prior months' per-level baselines and runs the MAA loop as a true memory cycle — reporting Audience, Engagement, and Conversion performance against previous periods, not a blended snapshot — and logs a meta-article example each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: gct-goals-content-targeting, maa-cycle-metrics-analysis-action, /dad, /social-amplification

END

START

---
name: gct-goals-content-targeting
description: Define Goals, Content, and Targeting for every campaign and page before launch, so what you're trying to achieve, what you'll say, and who will see it are aligned and written down.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# GCT (Goals, Content, Targeting)

**Use this when** any campaign, page, or piece of content is about to launch — or when one is underperforming and you suspect the goal, message, and audience were never aligned.

## Inputs
- The business outcome this asset must serve (lead, sale, booking, authority)
- Available content and proof assets (videos, testimonials, articles)
- Audience knowledge: who buys, who influences, existing custom audiences

## Steps
1. Define the triangle: **Goals** (the measurable business outcome), **Content** (the message and creative that earns it), **Targeting** (the specific people who see it). Every campaign and page gets all three, in that order.
2. **Goals:** write one numeric goal tied to revenue or pipeline (e.g., target CPA, leads/month, ROAS) — not vanity reach. If you can't state the number, stop here.
3. **Content:** choose or produce content that proves the goal's promise — real customer questions answered, real results shown. Greatest hits before new experiments (90/10 rule).
4. **Targeting:** name the exact audience — funnel level (cold/warm/conversion), custom audiences, lookalikes, or search intent — and confirm the content actually speaks to those people.
5. Run the alignment check: read G, C, and T aloud as one sentence — "We will achieve [Goal] by showing [Content] to [Targeting]." If the sentence is absurd, fix the weak corner before spending.
6. Document the GCT in the campaign/page brief so the MAA cycle can later judge performance against the stated goal, not a retrofitted one.
7. Measure it: in each MAA review, mark whether misses were a G, C, or T failure — that classification drives the fix.

## Definition of done (QA checklist)
- [ ] A written, numeric Goal exists for the asset
- [ ] Content is named and demonstrably supports the goal (proof, not claims)
- [ ] Targeting is specific: funnel level plus audience definition
- [ ] The one-sentence G-by-C-to-T alignment check reads true
- [ ] GCT brief stored where the weekly MAA report can reference it
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) drafts the GCT brief for every asset before launch and loops until the Definition of done fully passes — numeric Goal, proof-backed Content, specific Targeting, and an alignment sentence that reads true — blocking launch rather than shipping at 90%.
It self-verifies by reading G, C, and T back as one sentence and fixing the weak corner before any spend.
Because briefs persist in memory, the MAA loop becomes a true memory cycle: each review judges performance against the originally stated goal (no retrofitting), classifies misses as G, C, or T failures versus prior campaigns, and logs a meta-article example each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: funnel-levels-audience-engagement-conversion, stage-2-goals-mission-90-day-goals-cpa-roas-budget, maa-cycle-metrics-analysis-action, /dad

END

START

---
name: kill-underperformers-scale-winners
description: Act on the weekly diagnosis — cut campaigns and content that miss target, and gradually increase investment in what works — so budget continuously migrates toward proof.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Kill underperformers, scale winners

**Use this when** the weekly MAA analysis is done and it's time to act — this is the Action corner of the MAA triangle, executed without sentiment.

## Inputs
- The diagnosed underperformer list and the winners list (from the MAA analysis)
- Target cost per result (CPA/ROAS) per item, from the GCT/Stage 2 goals
- Ad account and publishing access to actually pause, edit, and re-budget

## Steps
1. Set the kill rule before looking at favorites: anything past its evaluation window and above target cost per result gets cut. Sunk cost is not an argument; the ad spend is gone either way.
2. **Kill:** pause every flagged underperformer now — don't taper "to be safe." If the diagnosis was fixable (creative/targeting/offer) and it hasn't had its one retry, relaunch the fixed variant as a new test instead of letting the old one run.
3. **Scale winners gradually:** increase budget on items beating target — but no more than 2× per adjustment (per /dad), because abrupt jumps reset delivery optimization and can break what was working.
4. Extend winners sideways as well as up: apply winning creative to new audiences via switch boosts, and feed proven content into the 90% greatest-hits pool.
5. Reallocate the freed budget from kills to the scaled winners the same day, so total spend keeps working instead of idling.
6. Log every kill and scale decision — item, metric, threshold, action, date — in the Friday MAA report; next week's first check is whether the scaled winners held their cost per result.

## Definition of done (QA checklist)
- [ ] Every diagnosed underperformer paused (or relaunched as a fixed variant) — none left running on hope
- [ ] No winner's budget increased more than 2× in a single adjustment
- [ ] Freed budget reallocated to winners, not left unspent
- [ ] Every action logged with item, metric, threshold, and date in the MAA report
- [ ] Scaled winners flagged for next week's first review
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) executes the Action corner without sentiment: it pauses every flagged underperformer the same day, scales winners no more than 2× per adjustment, and loops until the Definition of done fully passes — nothing left running on hope, freed budget reallocated, every decision logged with item, metric, threshold, and date.
It self-verifies by re-reading the ad account state after acting to confirm the pauses and budget changes actually took.
Memory closes the loop as a true MAA memory cycle: next run opens by checking whether last week's scaled winners held their cost per result versus prior periods, and a meta-article example is logged each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles (parent methodology: /maa)
- Related, in run order: analyze-why-underperformers-fail, content-strategy-90-greatest-hits-10-new, submit-weekly-maa-report-every-friday, /dad

END

START

---
name: learn-do-teach-apprentice-model
description: Run the Learn, Do, Teach apprentice model — study the canonical material, execute the task under review, then teach it — so skills compound into team capacity instead of staying with one expert.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Learn, Do, Teach apprentice model

**Use this when** onboarding an apprentice, VA, or new team member to any Task Library skill — or when you've "done" something for months but never proven mastery by teaching it.

## Inputs
- The target skill, with its definitive article and skill.md from the Task Library
- A real project to practice on (never train on hypotheticals)
- A senior reviewer who already owns the skill, and a future learner to teach

## Steps
1. Define the model: **Learn** (absorb the canonical material), **Do** (execute on real work under review), **Teach** (transfer it to the next person). You haven't mastered a skill until you've taught it and your student succeeded.
2. **Learn:** read the skill's definitive article and skill.md, and study the linked examples/meta-articles. Write down questions; unanswered ones are documentation gaps to flag.
3. **Do:** run the skill.md on a real project. The senior reviewer checks output against the Definition-of-done checklist at the 10% draft stage and at completion (Management triangle cadence).
4. Repeat the Do stage until runs pass QA without correction — consecutive clean runs, not one lucky one.
5. **Teach:** train the next apprentice using the same materials, and document your run as a meta-article so the teaching becomes a public, linkable example.
6. Promote: the teacher now owns review duty for that skill, freeing the senior to climb to higher-leverage work — this is how delegation compounds.
7. Measure it: track each person's skills by stage (Learn/Do/Teach), QA pass rate, and number of meta-articles produced; review movement quarterly.

## Definition of done (QA checklist)
- [ ] Learner consumed the definitive article, skill.md, and linked examples
- [ ] At least two consecutive real runs passed the skill's Definition-of-done without correction
- [ ] Learner taught the skill to a next person who then passed QA
- [ ] A meta-article documents the run and links back to the hub
- [ ] Skill-stage roster (who is at Learn/Do/Teach per skill) updated
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) runs the full Learn-Do-Teach arc on each skill: it absorbs the definitive article and skill.md, executes on real work, and loops the Do stage until consecutive runs pass the Definition of done without correction — never settling for one lucky pass.
It self-verifies against the skill's QA checklist before claiming a clean run, and flags every unanswered question as a documentation gap.
Memory holds the skill-stage roster and QA pass rates across quarters — a true MAA memory cycle comparing movement period over period — and the Teach step is fulfilled by logging a meta-article example from each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: management-communicate-iterate-delegate, systematization-content-checklists-software, personal-efficiency-do-delegate-delete

END

START

---
name: maa-cycle-metrics-analysis-action
description: Run the continuous MAA cycle — Metrics, Analysis, Action — so every number collected leads to a diagnosis and every diagnosis leads to a concrete change.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# MAA cycle (Metrics, Analysis, Action)

**Use this when** reporting has become numbers-without-decisions, or decisions are being made on gut feel — the loop reconnects measurement to action.

## Inputs
- Access to the measurement stack: analytics, search console, ad platforms, CRM/revenue data
- The goals and target CPA/ROAS these metrics are judged against (from GCT)
- Last period's MAA report, so this cycle compares against the previous one

## Steps
1. Define the loop: **Metrics** (what happened — the numbers), **Analysis** (why it happened — the diagnosis), **Action** (what we change — kill, scale, or iterate). One without the other two is waste.
2. **Metrics:** pull the same standing metric set every cycle, across the full pipeline (content → rankings → traffic → revenue) and across funnel levels. Consistency beats volume.
3. **Analysis:** for each metric materially above or below target, write one plain-language sentence on why — creative, targeting, or offer for ads; placement, title, or content for organic.
4. **Action:** convert every analysis into a dated, owned action — kill the underperformer, scale the winner (gradually), or iterate one variable and retest.
5. Close the loop weekly: the actions from this cycle become the first metrics checked next cycle (did the change work?).
6. Measure it: every Friday MAA report must show all three columns — a metric with no analysis, or an analysis with no action, fails QA.

## Definition of done (QA checklist)
- [ ] Standing metric set pulled for the period, same definitions as last cycle
- [ ] Every outlier metric has a one-sentence analysis (why)
- [ ] Every analysis has a dated, owned action (kill / scale / iterate)
- [ ] Last cycle's actions reviewed for effect before new actions are set
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

This task is the natural home for a persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models): it pulls the same standing metric set every cycle with zero definition drift and loops until all three columns are complete — every outlier metric carries a one-sentence analysis and a dated, owned action, not 90% of them.
It self-verifies by failing its own report whenever a metric lacks an analysis or an analysis lacks an action.
Memory makes the loop real: the agent opens each cycle by checking last cycle's actions against this cycle's numbers — a true memory cycle, compared period over period — and logs a meta-article example from every run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles (parent methodology: /maa)
- Related, in run order: submit-weekly-maa-report-every-friday, show-whats-working-and-what-isnt, analyze-why-underperformers-fail, kill-underperformers-scale-winners, measure-content-rankings-traffic-revenue

END

START

---
name: management-communicate-iterate-delegate
description: Run the Management triangle — Communicate, Iterate, Delegate — to catch issues early, improve work through fast feedback, and hand off responsibility progressively.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Management (Communicate, Iterate, Delegate)

**Use this when** delegated work keeps coming back wrong, deadlines slip silently, or you're managing people (or agents) without a feedback system.

## Inputs
- A roster of who owns what (people, VAs, or AI agents) with current assignments
- A communication channel and cadence everyone has agreed to (daily check-in, weekly report)
- The checklists/skill.md files that define what "done" looks like for each delegated task

## Steps
1. Define the triangle: **Communicate** (surface status and blockers early), **Iterate** (review drafts and improve in small fast cycles), **Delegate** (hand off progressively larger responsibility as quality proves out).
2. **Communicate:** require a short status from every owner on a fixed cadence — what shipped, what's blocked, what's next. Silence is treated as a blocker, not as good news.
3. **Iterate:** review work at the 10% draft stage, not at 90% — catching a wrong direction early costs minutes, not days. Give feedback as specific edits against the checklist, never "make it better."
4. **Delegate:** start each person on one small, checklist-backed task; expand scope only after consecutive clean runs. Pair this with the Learn, Do, Teach apprentice model.
5. When the same correction appears twice, stop and update the checklist or skill.md so the fix becomes systemic (Systematization triangle), not repeated verbally.
6. Measure it: track rework count, turnaround time, and how many tasks each person owns end-to-end; report trends in the weekly MAA cycle.

## Definition of done (QA checklist)
- [ ] Every delegated task has an owner, deadline, and linked checklist
- [ ] Status cadence is running — no owner silent past one cycle
- [ ] Early-draft (10%) reviews happening before full builds
- [ ] Repeat corrections converted into checklist/skill.md updates
- [ ] Rework and turnaround metrics tracked in the weekly report
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) runs this triangle on every owner — human, VA, or sub-agent — chasing the status cadence (silence escalated as a blocker), reviewing at the 10% draft stage, and looping until the Definition of done fully passes, not until most owners have reported.
It self-verifies by checking that every repeat correction became a checklist or skill.md update before closing the cycle.
Because it remembers across weeks, the MAA loop becomes a true memory cycle: rework counts, turnaround times, and end-to-end ownership are compared against prior periods, and a meta-article example is logged each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: personal-efficiency-do-delegate-delete, learn-do-teach-apprentice-model, systematization-content-checklists-software, submit-weekly-maa-report-every-friday

END

START

---
name: personal-efficiency-do-delegate-delete
description: Apply the Personal Efficiency triangle — Do, Delegate, Delete — so every incoming item is actioned immediately, handed off with instructions, or removed, keeping the operator at inbox zero.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Personal Efficiency (Do, Delegate, Delete)

**Use this when** your inbox, DMs, or task list are backing up and you need a repeatable triage system instead of willpower.

## Inputs
- Access to every inbox the operator works from (email, messages, task manager)
- At least one delegation target — a VA, teammate, or apprentice who can receive handoffs
- The operator's priorities mapped to the Three Pillars (marketing, operations, finance), so Delete decisions are objective

## Steps
1. Define the triangle: every incoming item gets exactly one of three verbs — **Do** (act now), **Delegate** (hand off), or **Delete** (decline/archive). There is no fourth bucket; "later" is not a verb.
2. Process each inbox top to bottom, touching every item once. If it takes under two minutes or only you can do it, **Do** it immediately.
3. If someone else can do it acceptably well, **Delegate**: forward with the goal, the deadline, and a link to the relevant checklist or skill.md — never a bare "handle this."
4. If it serves no goal in the Three Pillars, **Delete** it — unsubscribe, decline, or archive so it cannot resurface.
5. Repeat until every inbox reads zero, then schedule triage as a recurring daily block instead of reacting all day.
6. Log what was delegated and to whom so the Management triangle (Communicate, Iterate, Delegate) can follow up on quality.
7. Measure it: track the weekly Do/Delegate/Delete counts and time-to-zero in the Friday MAA report; a rising Delegate share means the system is compounding.

## Definition of done (QA checklist)
- [ ] All inboxes at zero at the end of the triage block
- [ ] Every delegated item has a named owner, a deadline, and linked instructions
- [ ] Nothing parked in a "later" pile — each item received Do, Delegate, or Delete
- [ ] Weekly Do/Delegate/Delete ratio recorded in the MAA report
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) owns the triage block end to end: it sweeps every connected inbox top to bottom and loops until the Definition of done fully passes — all inboxes at zero and every delegated item carrying owner, deadline, and linked instructions — not 90% processed.
It self-verifies by re-scanning each inbox after the pass and rejecting any item parked as "later."
Because it keeps memory across runs, it logs the weekly Do/Delegate/Delete counts and compares them against prior weeks in the Friday MAA report — a true memory cycle showing whether the Delegate share is compounding — and appends a meta-article example from each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: management-communicate-iterate-delegate, systematization-content-checklists-software, learn-do-teach-apprentice-model, submit-weekly-maa-report-every-friday

END

START

---
name: systematization-content-checklists-software
description: Move any recurring task up the Systematization ladder — from documented content, to a checklist anyone can run, to software/agent automation — so quality stops depending on memory.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Systematization (Content → Checklists → Software)

**Use this when** a task is done repeatedly but lives in someone's head, results vary by who does it, or you're correcting the same mistake for the third time.

## Inputs
- One recurring task that currently runs ad-hoc
- The person who does it best (their walkthrough is the raw material)
- A home for the artifacts: the definitive article hub and the Task Library skills folder

## Steps
1. Define the ladder: **Content** (the knowledge is written down once, canonically), **Checklists** (the knowledge becomes numbered steps with pass/fail criteria), **Software** (the stable steps run automatically). Never skip a rung — automating an undocumented process automates the errors.
2. **Content:** record the best operator doing the task while narrating; turn it into (or fold it into) the concept's definitive article so there is one canonical write-up, not competing versions.
3. **Checklists:** extract the SOP into a skill.md per the Task Library Standard — inputs, imperative steps, and a Definition-of-done checklist an agent or new hire can run without asking questions.
4. Run the checklist manually at least three times with different operators; every question they ask is a missing step — edit the checklist until runs are question-free.
5. **Software:** automate only the steps that survived unchanged across runs (e.g., agent runs the skill.md, scripts handle the repetitive parts); keep judgment steps human until they stabilize.
6. Measure it: track time-per-run, error/rework rate, and what fraction of runs are done by someone other than the original expert — all three should improve as the task climbs the ladder.

## Definition of done (QA checklist)
- [ ] The task has a single canonical write-up on its definitive article (no competing docs)
- [ ] A skill.md exists with inputs, steps, and an objective Definition-of-done
- [ ] Checklist validated by 3+ runs, including by someone other than the expert
- [ ] Stable steps automated or assigned to an agent; judgment steps explicitly flagged
- [ ] Time-per-run and rework rate baselined and tracked
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The Task Library itself — definitive article → skill.md → examples — is this triangle applied to BlitzMetrics' own SOPs.)

## Run on a persistent agent (Fable 5)

This triangle is what a persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) embodies: it drafts the canonical write-up, extracts the skill.md, then runs the checklist itself repeatedly — treating every question it has to ask as a missing step — and loops until the Definition of done fully passes, including validated runs by operators other than the expert.
It self-verifies by re-running the finished checklist cold and refusing to mark Software-rung steps automated until they survive unchanged across runs.
Memory baselines time-per-run and rework rate and compares them against prior periods in the MAA loop — a true memory cycle — with a meta-article example logged each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: management-communicate-iterate-delegate, learn-do-teach-apprentice-model, /content-factory

END

START

---
name: three-pillars-marketing-operations-finance
description: Map the business onto its Three Pillars — Marketing, Operations, Finance — assign one health metric to each, and rebalance effort toward the weakest pillar.
category: Strategy & Measurement
stage: —
definitive_article: /nine-triangles
status: complete
---

# Three Pillars (Marketing, Operations, Finance)

**Use this when** you need a whole-business diagnosis — growth has stalled, work feels busy but unprofitable, or you must decide where the next hour or dollar goes.

## Inputs
- A list of all recurring activities, roles, and tools in the business
- Basic numbers: pipeline/leads, delivery throughput and quality, revenue/margin/cash
- The owner's 90-day goals, so pillar priorities tie to something concrete

## Steps
1. Define the triangle: every business runs on **Marketing/Sales** (demand: attention, leads, deals), **Operations** (delivery: fulfilling what was sold), and **Finance** (fuel: pricing, margin, cash flow). A business is only as strong as its weakest pillar.
2. Map every recurring activity, role, and tool to exactly one pillar. Anything that maps to none is a Delete candidate (Personal Efficiency triangle).
3. Assign one primary health metric per pillar — e.g., Marketing: qualified leads or pipeline value; Operations: on-time delivery or capacity utilization; Finance: gross margin or cash runway.
4. Score each pillar against its 90-day goal and identify the constraint — the weakest pillar that caps the other two (great marketing can't save broken delivery; great delivery can't save negative margin).
5. Rebalance: move effort, budget, and the next hires/delegations toward the constraint pillar; write the decision down with a review date.
6. Measure it: review all three pillar metrics in the weekly MAA report so no pillar drifts unwatched between strategic reviews.

## Definition of done (QA checklist)
- [ ] Every recurring activity and role mapped to exactly one pillar
- [ ] One primary metric per pillar, with current value and target
- [ ] The constraint pillar named, with a written rebalancing action and review date
- [ ] All three pillar metrics appearing in the weekly MAA report
- [ ] Linked back to the definitive article and relevant siblings
- [ ] Complies with Blog Posting Guidelines (if it publishes content)

## Example(s)
- Example needed — run the Meta-Article Prompt after first real run. (The hub at /nine-triangles links live examples; pull the closest match into this slot.)

## Run on a persistent agent (Fable 5)

A persistent, max-effort agent (Claude Fable 5 or comparable OpenAI/Google models) keeps the whole-business map alive: it re-maps activities, pulls all three pillar metrics every week, and loops until the Definition of done fully passes — every activity assigned, one metric per pillar with value and target, the constraint named with a written action and review date.
It self-verifies by confirming no activity is unmapped and no pillar metric is missing from the weekly report before closing.
Memory makes the diagnosis longitudinal: the agent runs the MAA loop as a true memory cycle, scoring each pillar against prior periods so a slowly weakening pillar is caught early, and logs a meta-article example each run.
See `boil-the-ocean.md` for the full operating principles.

## Definitive article & links
- Hub: /nine-triangles
- Related: personal-efficiency-do-delegate-delete, maa-cycle-metrics-analysis-action, submit-weekly-maa-report-every-friday

END