Account Health Autopilot: Weekly Customer Health Scoring in Your CRM
Your clone grades every customer's health each week from calls, email, cases and tickets, and writes the evidence into your CRM after you approve.
The problem
Health scores go stale because the real signals are scattered across transcripts, inboxes, cases and tickets, and nobody has time to review every account every week. Failed lookups and quiet accounts make risky customers look healthy until renewal.
Account Health Autopilot: Weekly Customer Health Scoring in Your CRM
Version 1.1.0 · Last updated 2026-10-22 · Difficulty: Advanced · Setup time: 60–120 minutes
Every week your clone reads the last 7 days of calls, emails, support cases and tickets for every customer, grades each account's health, and writes the results into three fields in your CRM (Salesforce or HubSpot), after you approve the changes. You get one report with who moved, why, and which accounts are quietly at risk.
1. Overview and value
Health scores in most CRMs are stale. Someone updates them before a QBR or a renewal, and by then the signals are weeks old. The facts that matter (an angry email, a cluster of bugs, a champion who stopped joining calls, an integration request nobody logged) are scattered across transcripts, inboxes, the CRM and the ticket tracker.
The Account Health Autopilot fixes that. Every week at {RUN_TIME} your clone:
- sweeps the previous 7 days across four sources: call transcripts, email, CRM support signal (Salesforce Cases, or HubSpot notes/tasks/engagements) and the Linear tracker,
- tells "no results" apart from "lookup failed", so a broken connection never makes an account look healthy,
- verifies keyword hits by reading the source, so a customer named after a common word doesn't get false signals,
- grades each in-scope account on a 6-level health scale,
- drafts updates to three CRM fields: pain points, health grade and integrations needed,
- shows you the full proposed changes and writes only after you say yes,
- sends one weekly report with the health distribution, movers, silent-risk accounts and tracking gaps.
What you get:
| Benefit | What it looks like |
|---|---|
| Current health grades | Every in-scope account graded weekly from real evidence, not memory |
| Evidence you can trust | Direct quotes, case IDs and ticket IDs behind every grade |
| Early warning | "Silent risk" accounts flagged before they show up as churn |
| Clean CRM data | Pain points and integration requests kept current, never blank |
| Fewer surprises at renewal | Downgrades and their reasons surface the week they happen |
| Time back | Hours of manual account review per week replaced by a 15-minute approval |
Quick-start alternative: the prebuilt skill Weekly-Account-Health-Update can be attached through the platform for a faster start. This card's custom skill gives you full control over the scale, the sources, the three fields and the approval flow.
2. Who it's for
- Customer Success teams who own health scores and renewals and want them current every week.
- RevOps who want health data in the CRM to be consistent, evidence-based and reportable.
- Leadership who want a weekly view of the customer base: distribution, movers and risks.
- Support leads who want case and ticket patterns reflected in account health.
It works for current customers (per your {CUSTOMER_DEFINITION}). Prospects, internal records and partner/referral records are skipped on purpose.
3. How it works
┌───────────────────────────────────────────────────────────────────┐
│ Every week at {RUN_TIME} (scheduled task) │
└───────────────────────────────┬───────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────────────────┐
│ "Account Health Autopilot" skill │
│ │
│ 1. Build the account list ──► {ACCOUNT_SCOPE}, minus │
│ {EXCLUSIONS}, with {NAME_MAPPINGS}│
│ 2. Sweep last 7 days (in parallel): │
│ Transcripts · Email (name AND domain) · │
│ CRM cases (all statuses + text search) · Ticket tracker │
│ Each source: "results" / "no results" / "lookup FAILED" │
│ 3. Verify hits by reading the source (no false positives) │
│ 4. Grade health on the 6-level scale ({HEALTH_SCALE}) │
│ quiet week ≠ grade change · flag silent risk │
│ 5. Draft 3 fields per record ──► pain points · health · │
│ integrations needed │
│ 6. Check {REQUIRED_FIELDS} ──► blocked records listed, not │
│ guessed │
│ 7. Show proposed changes ──► WAIT for your "yes" │
│ (first run = dry run, no writes) │
│ 8. Write in batches of 2–4 ──► {WRITE_TARGET} in your CRM │
└───────────────────────────────┬───────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────────────────────┐
│ Weekly report ──► {REPORT_RECIPIENTS} and/or {TEAM_CHANNEL} │
│ updates · failures · distribution · movers · silent risk · gaps │
└───────────────────────────────────────────────────────────────────┘The health scale
The default scale has six levels. You can rename them or change the definitions with {HEALTH_SCALE}.
| Grade | Default definition |
|---|---|
| Bright Green | Expanding or about to expand; champion engaged; positive feedback; no open serious issues |
| Green | Healthy and stable; regular, normal usage and engagement; issues are routine and being handled |
| Yellow | Some concern: repeated issues, slower responses, a key contact change, or mild frustration |
| Orange | Real risk: escalations, open serious issues, a stalled rollout, budget or priority questions, or silent risk |
| Red | Likely to churn or downgrade without action: explicit dissatisfaction, evaluating competitors, renewal at risk |
| Black | Churned, or has given churn / non-renewal notice |
Two rules apply every week:
- A quiet week alone never changes a grade. No news is not good news or bad news by itself.
- Silent risk is worse than noise. An account with no cases, no emails and no calls because nobody is using the product is a bigger worry than an account filing bugs. The clone flags these separately.
4. What the clone does each week
- Builds the account list from
{ACCOUNT_SCOPE}, removes{EXCLUSIONS}(internal and referral/partner records), and uses{NAME_MAPPINGS}to connect aliases, product names and parent/child accounts. - Sweeps four sources for the previous 7 days, and records for each one whether it returned results, returned nothing, or failed.
- Reads the evidence behind every keyword hit before counting it.
- Grades each account, compares with the current grade, and writes a one-line reason for any change.
- Drafts the three fields, carrying forward existing detail that is still true.
- Shows you a change table (account, old grade → new grade, reason, field differences), with downgrades, lost detail and blocked records flagged.
- Writes only after your "yes", in small batches, touching only the three fields.
- Sends the weekly report.
What it never does:
- Never writes to the CRM without your approval of that week's changes.
- Never touches any field other than the three you name.
- Never guesses values for required fields to get past a validation rule. It lists the record as blocked.
- Never emails customers. The only messages it sends are the report and approval requests to
{REPORT_RECIPIENTS}/{TEAM_CHANNEL}. - Never treats a failed lookup as "no activity".
- Never changes a grade just because a week was quiet.
5. Setup walkthrough
The quickest path: download CLONE-INSTRUCTIONS.md and give it to your clone. It will check what's already connected, ask you for the placeholder values, offer to help create the CRM fields, show you a plan, and set up what it can after you approve. The steps below are what happens, so you know what to expect.
Step 1: Check requirements (10 min) Open REQUIREMENTS.md and run through the pre-flight checklist. You need a Salesforce or HubSpot operator with read and write access, Gmail or Outlook, Linear (recommended), a transcript source and the ability to create a scheduled task.
Step 2: Hand the instructions to your clone (2 min) Paste or upload CLONE-INSTRUCTIONS.md into a chat with your clone and say: "Please set up this use case for me. Show me a plan before changing anything."
Step 3: Review the discovery table (5 min) The clone reports which skills/operators and connections it has, and whether the three CRM fields exist.
Step 4: Answer the placeholder questions (10–15 min) See the table in section 6. The ones that take the most thought are {ACCOUNT_SCOPE}, {NAME_MAPPINGS} and {EXCLUSIONS}.
Step 5: Create the three CRM fields if needed (10–30 min) If they don't exist yet, the clone gives you the field type, picklist values and help text for each one (Salesforce or HubSpot). It creates them only if its CRM operator has admin rights and you approve. Otherwise a CRM admin creates them using the clone's steps.
Step 6: Approve the plan (2 min) The clone lists exactly what it will attach, create and schedule. Say "yes" only when it looks right.
Step 7: Do your part (15–30 min) Things only you (or your admins) can do:
- Complete sign-in (OAuth) for the CRM, email, tracker and file storage connections.
- Share the transcripts folder
{TRANSCRIPTS_FOLDER}with the clone. - Make sure the CRM integration user can edit the three fields (field-level permissions).
- Tell the clone about any validation rules that apply to
{WRITE_TARGET}records.
Step 8: Save the skill (5–10 min) If the clone can't create custom skills directly, it gives you the full skill text in a copy-paste block with exact steps. Read it before you save it.
Step 9: Run the dry run (20–30 min) The first run is a dry run: the clone builds the full change table and report but writes nothing. Review the grades with someone who knows the accounts.
Step 10: Approve the first real write When you're happy with the dry run, tell the clone to switch off dry-run mode. From then on, each week you review the change table and reply "yes".
6. Placeholders to decide
| Placeholder | What it means | Example |
|---|---|---|
{CLONE_NAME} | Your clone's display name | "Ava" |
{CLONE_INBOX} | The clone's own email address | ava@yourcompany.com |
{YOUR_COMPANY_DOMAINS} | Your company's email domains (internal = these) | yourcompany.com, yourcompany.io |
{RUN_TIME} | When the weekly run happens (with time zone) | Monday 7:00 AM America/New_York |
{CUSTOMER_DEFINITION} | How your CRM marks a current customer | "Account Type = Customer AND Status = Active" |
{ACCOUNT_SCOPE} | Which accounts or opportunities are graded | All current customers; or only renewal opportunities closing in the next 12 months |
{WRITE_TARGET} | Where the three fields live | Account (one grade per customer) or Opportunity (one per deal/renewal) |
{TRANSCRIPTS_FOLDER} | Where call transcripts are stored | Google Drive "Customer Calls/Transcripts", a OneDrive folder, or "my meeting archive" (plus call archive for phone calls) |
{NAME_MAPPINGS} | Aliases, product names and parent/child links | "Northwind" = "Northwind Traders Ltd"; "Contoso Health" is a child of "Contoso Group" |
{EXCLUSIONS} | Records never graded | Your own company's test account; referral partners; "Partner - " accounts |
{REQUIRED_FIELDS} | Fields a validation rule requires before a save | Industry, Renewal Date, Customer Success Manager |
{HEALTH_SCALE} | Grade names and definitions | Default 6 levels (Bright Green to Black), or your own |
{PAIN_POINTS_FIELD} | Long text field for pain points | "Customer Pain Points" |
{HEALTH_FIELD} | Picklist field for the grade | "Account Health" |
{INTEGRATIONS_NEEDED_FIELD} | Text field for integration requests | "Integrations Needed" |
{REPORT_RECIPIENTS} | Who receives the weekly report and approval request | cs-leads@yourcompany.com |
{TEAM_CHANNEL} | Optional chat channel for the report | #customer-health (Slack) or a Teams channel |
Tip: set {RUN_TIME} early in the week so the approver has time to review the change table before the Monday or Tuesday pipeline and CS meetings.
7. What to expect day to day
- Every week at {RUN_TIME}: the sweep starts. Large books of business can take a while; the clone works through accounts in order and reports progress.
- Shortly after: an approval message lands with
{REPORT_RECIPIENTS}(and/or{TEAM_CHANNEL}): the change table, flagged downgrades, records where detail would be lost, blocked records and failed sources. - You review (10–15 minutes): reply "yes", "yes except Northwind", or ask questions. The clone can explain any grade with its evidence.
- After approval: the clone writes in small batches and sends the final weekly report with what was updated, what failed (with exact error messages), the health distribution, movers and why, silent-risk accounts and tracking gaps.
- If you don't reply, nothing is written. The clone reminds you once and the proposed changes stay in the report.
- Off-cycle: you can ask "Run Account Health Autopilot for Contoso only" at any time, with the same approval step.
8. Customizing
Health scale. Rename levels, change definitions, or use fewer levels. Change {HEALTH_SCALE} in the skill and update the picklist values in your CRM to match exactly.
Lookback window. The default is 7 days. You can change it to 14 days for a biweekly cadence (change {RUN_TIME} too).
Scope. Grade all customers, only a segment (e.g. enterprise), only one CSM's book, or only renewal opportunities.
Sources. Add or remove sources at any time, for example a product usage export kept in Google Sheets or Excel (very useful for spotting silent risk). The skill reports which sources worked.
Approval style. Keep full approval every week (recommended), or after a few weeks, ask for "auto-approve upgrades and unchanged grades; ask me about downgrades and lost detail". Change it in the skill's Guardrails.
Report format. Email only, chat only, or both; add a "top 5 at-risk accounts by renewal date" section; split by CSM.
9. Known gotchas
- A failed lookup is not zero results. If the email or case search fails and is counted as "nothing found", the account looks quiet and healthy. The skill reports every source as results / no results / failed, and never grades an account as healthier because a source failed.
- Customers use personal email addresses. Contacts often write from gmail.com or outlook.com. That's why email is searched by company name and domain, plus known contact addresses.
- Cases get filed under the wrong account. Support cases are often logged against a parent account, a reseller or a placeholder. The skill runs a secondary text search on case subjects and descriptions to catch them.
- Company-name false positives. A customer named after a common word (think "Summit", "Apex" or "Bright") will match lots of unrelated emails and transcripts. The skill reads each hit to confirm it's really about that customer.
- Validation rules block saves. If your CRM requires certain fields (
{REQUIRED_FIELDS}) before a record can be saved, the write will fail on records missing them. The clone never invents values; it lists the record as blocked so a person can fill in the gap. - Overwriting can lose detail. The pain points field is overwritten each week. The skill carries forward unique detail that's still true and flags anything it plans to drop, so you can say no.
- A quiet week shouldn't change a grade. Holidays and slow weeks happen. Only real evidence moves a grade.
- Silent risk hides in plain sight. No activity at all can mean nobody's using the product. These accounts are flagged, not marked healthy.
- Field-level permissions. The CRM integration user (the account the clone's CRM operator signs in as) needs edit rights on the three fields specifically. A user who can edit the record but not the field gets a permission error. This is the most common first-week failure.
- Picklist values must match exactly. "Bright green" vs "Bright Green" can fail or create a stray value. Keep
{HEALTH_SCALE}and the picklist identical. - Name mappings drift. New products, acquisitions and renamed accounts break matching. Review
{NAME_MAPPINGS}every quarter. - The clone only sees what's shared with it. If transcripts live in a folder it can't open, or support is in a tool it isn't connected to, that source shows as failed or missing.
- Use exact skill/operator names as they appear in your skill catalog. The clone checks them during discovery.
- Read every instruction before saving it into a skill. You're responsible for what your clone does and what it writes into your CRM.
10. FAQ
Does this work with my CRM? Yes, if your CRM is Salesforce or HubSpot. Those are the two CRMs the clone has operators for today. See the Salesforce to HubSpot mapping in REQUIREMENTS.md. On HubSpot there is no tickets/cases operator, so the support signal comes from notes, tasks and engagements.
Is there a faster option? Yes. The prebuilt skill Weekly-Account-Health-Update can be attached through the platform as a quick start. Use this card when you want full control over the scale, sources, fields and approval flow.
Will it change anything in my CRM without asking? No. Every week it shows the full change table and writes only after an explicit "yes". The first run is a dry run with no writes at all.
Which fields will it touch? Only the three you name: {PAIN_POINTS_FIELD}, {HEALTH_FIELD} and {INTEGRATIONS_NEEDED_FIELD}. Nothing else.
Do the fields have to exist already? No. The clone gives you the exact field setup (type, picklist values, help text) and can create them if its CRM operator has admin rights and you approve.
Will the clone email my customers? No. It reads email; it sends only the report and approval request to your team.
What if I don't have Linear or transcripts? It still works with fewer sources, but grades are less reliable. Each missing source is listed in every report so nobody mistakes "not checked" for "nothing happened".
Can it grade opportunities instead of accounts? Yes. Set {WRITE_TARGET} to opportunity (useful when one customer has several contracts or renewals).
How long does the weekly approval take? Usually 10–15 minutes to read the change table, longer if there are many downgrades worth discussing.
11. Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
| No approval message arrived | Scheduled task missing, paused, or wrong time zone | Ask the clone to list its scheduled tasks; check {RUN_TIME} time zone |
| Every account came back Green | A source failed and was treated as "no results", or dry run used too few sources | Check the source status section; fix the connection and re-run |
| "INSUFFICIENT_ACCESS" or "field not writable" errors | Integration user lacks field-level edit permission | CRM admin grants edit on the three fields to the integration user |
| "Required field missing" / validation error | A validation rule needs {REQUIRED_FIELDS} filled | Fill the missing values on the blocked records; the clone retries next run |
| Picklist error on the health field | Grade name doesn't match the picklist value | Make the picklist values and {HEALTH_SCALE} identical |
| Unrelated emails cited as evidence | Company name is a common word | Add the name to {NAME_MAPPINGS} with "match only with domain"; the skill already verifies hits |
| A known escalation was missed | Case filed under another account, or contact used a personal address | Add the alias or parent/child link to {NAME_MAPPINGS}; check the secondary case search ran |
| Partner or internal account was graded | Not in {EXCLUSIONS} | Add it to {EXCLUSIONS} |
| Pain points lost older detail | Detail judged no longer true, or approver missed the "lost detail" flag | Ask the clone to restore it next run; review the lost-detail column before approving |
| Transcripts: "lookup failed" | Folder not shared with the clone, or file storage connection expired | Share {TRANSCRIPTS_FOLDER} with {CLONE_INBOX}; re-run sign-in |
Version: 1.1.0 · Last updated: 2026-10-22 · Part of the Clone Use Case Library.
Paste these instructions into clone chat
# Clone Instructions: Account Health Autopilot (Weekly Customer Health Scoring in Your CRM)
> **For the clone.** Your user has handed you this file. Follow it step by step.
> **Version 1.1.0 · Last updated 2026-10-22**
---
## 1. Role and goal
You are setting up the **Account Health Autopilot** use case for your user.
When setup is done, every week at `{RUN_TIME}` you will run a skill called **Account Health Autopilot** that:
1. builds the list of in-scope accounts or opportunities (`{ACCOUNT_SCOPE}`), applying `{NAME_MAPPINGS}` and `{EXCLUSIONS}`,
2. sweeps the previous 7 days across four sources: call transcripts, email, the CRM support signal (Salesforce Cases, or HubSpot notes/tasks/engagements) and the Linear tracker,
3. reports every source as "results", "no results" or "lookup failed", and verifies keyword hits by reading them,
4. grades each account on a 6-level health scale (`{HEALTH_SCALE}`),
5. drafts updates to three CRM fields: `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}`,
6. shows the full proposed changes and waits for approval,
7. writes approved changes in small batches to `{WRITE_TARGET}` records,
8. sends a weekly report to `{REPORT_RECIPIENTS}` and/or `{TEAM_CHANNEL}`.
Your job right now is **setup only**: discover what's available, check whether the three CRM fields exist, collect the user's settings, propose a plan, do the parts you're able to do after approval, and clearly hand over the parts only the user can do.
**Tools for this use case:** CRM is Salesforce (`SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`) or HubSpot (`HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator`). HubSpot has no tickets/cases operator, so the support signal comes from notes, tasks and engagements. Tracker is Linear (`Linear_Operator`). Email is Gmail (`GoogleGmailOperator`) or Outlook. Transcripts come from a `GoogleDriveCoreOperator` or `Microsoft_OneDrive` folder, or `meeting_archive` (plus `call_archive` for phone calls). The report goes by email and/or Slack or Teams. Custom fields can only be created in Salesforce or HubSpot. If the user's tools are not on this list, say so plainly instead of improvising.
**Quick-start alternative:** the prebuilt skill **Weekly-Account-Health-Update** exists. Mention it to the user: it can be attached via the `platform` tool for a faster start, while the custom skill in section 7 gives full control. Continue with this card unless the user prefers the prebuilt skill.
Be honest about your limits. If a tool isn't available to you, you lack a permission, or a step fails, say so plainly and give the user the exact manual steps instead.
## 2. Safety rules (read before doing anything)
- **Plan first, then act.** Before you attach, create, schedule or change anything, show the user a numbered plan and wait for an explicit "yes". No yes = no changes.
- **Approval is per plan.** If the plan changes, show the new plan and ask again.
- **Never ask for, accept or handle passwords, API keys or tokens.** All connections are made by the user through the platform's own sign-in (OAuth) screens. If the user pastes a secret into chat, tell them not to and don't use it.
- **Never email customers during setup.** The only messages you may send during setup are a test report to the user (and only after they approve it).
- **No CRM writes during setup.** During setup you only read from the CRM, ticket tracker, email and file storage. The one exception is creating the three custom fields, and only if the user approves that specific step and your CRM operator has the rights to do it. Never edit customer records during setup; the test plan uses a dry run and a test record.
- **Read-only everywhere except the three fields.** The finished skill reads from email, transcripts, cases and the tracker, and writes only the three named fields on `{WRITE_TARGET}` records, only after approval.
- **Don't guess names.** Use exact skill/operator names as they appear in the user's skill catalog, and exact CRM field names and picklist values.
## 3. Discovery
Check what you already have. Use the platform tool to list your attached skills/operators and connections, and use `describeOperator` on each relevant operator to confirm what it can do (read, write, search, create fields) and whether its connection is active.
Look for:
| Need | Required? | Examples of what to look for |
|---|---|---|
| CRM operators | **Required** (read + write) | Salesforce: `SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`. HubSpot: `HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator` |
| Email connection | **Required** | `GoogleGmailOperator` or Outlook (read + send) |
| Transcript source | **Required** | `GoogleDriveCoreOperator` or `Microsoft_OneDrive` access to `{TRANSCRIPTS_FOLDER}`, or `meeting_archive` (plus `call_archive` for phone calls) |
| Scheduled task | **Required** | Ability to create a recurring scheduled task |
| Issue tracker | Optional (strongly recommended) | `Linear_Operator` |
| Messaging | Optional | Slack or Microsoft Teams (to post the report to `{TEAM_CHANNEL}`) |
| Product usage export | Optional | A usage sheet in `GoogleSheets-Operator` or `Microsoft_Excel` (helps spot silent risk) |
Then, if the CRM is connected, check the CRM itself (read only):
- Do fields (Salesforce) or properties (HubSpot) matching `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}` already exist on the account or opportunity object? What are their types and picklist values?
- Can your CRM operator write to them (if `describeOperator` or a field-metadata lookup shows this)?
- Can your CRM operator create custom fields (admin/metadata rights)?
- Are there obvious required fields or validation rules on the object?
**Report the results to the user in a table like this:**
| Item | Status | Exact name in catalog | Notes |
|---|---|---|---|
| CRM operators (Salesforce or HubSpot) | ✅ Connected / ⚠️ Attached, not signed in / ❌ Missing | … | Read? Write? Create fields? |
| Email | … | … | … |
| Transcript source | … | … | Folder visible? |
| Scheduled task | … | … | … |
| Linear | … | … | … |
| Slack / Teams | … | … | … |
| Product usage data | … | … | … |
| Pain points field | ✅ Exists / ❌ Missing / ❓ | … | Type, length |
| Health field | … | … | Picklist values |
| Integrations needed field | … | … | Type |
If you can't check something (for example, there's no way to read field metadata), mark it "❓ Couldn't check" and say why.
## 4. Collect placeholder values
Ask the user **once**, in a single short list. Offer the examples. Don't proceed with the plan until you have answers (the user may say "use the default" where a default is given).
> To set this up I need a few details:
>
> 1. **Run time** (`{RUN_TIME}`): when should I run each week, with time zone? *(default: Monday 7:00 AM your time zone)*
> 2. **Your company domains** (`{YOUR_COMPANY_DOMAINS}`): e.g. `yourcompany.com, yourcompany.io`.
> 3. **Customer definition** (`{CUSTOMER_DEFINITION}`): how does your CRM mark a current customer? e.g. "Account Type = Customer AND Status = Active".
> 4. **Scope** (`{ACCOUNT_SCOPE}`): which accounts or opportunities should I grade? *(default: all current customers)*
> 5. **Write target** (`{WRITE_TARGET}`): put the three fields on the **account** or the **opportunity**? *(default: account)*
> 6. **Field names** (`{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}`, `{INTEGRATIONS_NEEDED_FIELD}`): existing field names, or should I help you create them? *(defaults: "Customer Pain Points", "Account Health", "Integrations Needed")*
> 7. **Health scale** (`{HEALTH_SCALE}`): use the default 6 levels (Bright Green, Green, Yellow, Orange, Red, Black) or your own?
> 8. **Transcripts** (`{TRANSCRIPTS_FOLDER}`): which Drive/OneDrive folder holds call transcripts, or should I use my own meeting archive?
> 9. **Name mappings** (`{NAME_MAPPINGS}`): aliases, product names and parent/child links, e.g. "Northwind = Northwind Traders Ltd". *(can start empty)*
> 10. **Exclusions** (`{EXCLUSIONS}`): records I must never grade, e.g. internal test accounts, referral partners.
> 11. **Required fields** (`{REQUIRED_FIELDS}`): fields a validation rule requires before a save, if you know them. *(I'll also look.)*
> 12. **Report** (`{REPORT_RECIPIENTS}` and/or `{TEAM_CHANNEL}`): who gets the approval request and weekly report?
I'll fill in `{CLONE_NAME}` and `{CLONE_INBOX}` from my own profile and show them in the table.
Repeat the answers back in a table and ask the user to confirm.
## 5. What you can do yourself (after approval)
Present a plan like this, filled in with real names from discovery:
> **Proposed plan (nothing changes until you say yes):**
> 1. Attach these missing skills/operators from the catalog: *[list exact names]*.
> 2. *(Only if fields are missing and my CRM operator has admin rights)* Create the three CRM fields on `{WRITE_TARGET}` exactly as specified below.
> 3. Create the **Account Health Autopilot** skill using the text in section 7, with your values filled in, **dry-run mode ON**.
> 4. Create a scheduled task "Weekly Account Health Autopilot" that runs the skill at `{RUN_TIME}`.
> 5. Run one dry run now and send you the test report (to you only). No CRM writes.
>
> **You'll need to do:** *[list from section 6]*.
>
> Reply **yes** to proceed, or tell me what to change.
After a clear "yes":
1. **Attach skills/operators.** Use the platform tool to search the catalog and attach each required/optional item the user approved (exact names from the table in section 3). Confirm each with `describeOperator`. If an item needs a sign-in, tell the user (it goes on their list).
2. **Create the three CRM fields (only if approved and missing).** Use these specs, adjusted to the user's CRM:
| Field | Type | Values / limits | Help text |
|---|---|---|---|
| `{PAIN_POINTS_FIELD}` | Long text area (multi-line) | At least 2,000 characters (content kept under ~1,500) | "Updated weekly by {CLONE_NAME}. Most important fact first; upcoming changes in CAPS; quotes and case/ticket IDs." |
| `{HEALTH_FIELD}` | Picklist (single select, dropdown) | Bright Green, Green, Yellow, Orange, Red, Black (or `{HEALTH_SCALE}`), in that order | "Weekly health grade. See the health scale definitions." |
| `{INTEGRATIONS_NEEDED_FIELD}` | Long text area (or text, 255+) | Never blank; "None requested" if none | "Integration requests from the customer, with ticket IDs. Updated weekly." |
If your CRM operator **can't create fields or lacks admin rights**, say so and give the user (or their CRM admin) the steps for their CRM (Salesforce or HubSpot). Menu names may differ slightly:
- **Salesforce:** Setup → Object Manager → Account (or Opportunity) → Fields & Relationships → New → choose type (Text Area (Long) / Picklist) → enter label, length or values, help text → set field-level security (make it **visible and editable** for the integration user's profile or permission set) → add to page layout → Save.
- **HubSpot:** Settings → Data Management → Properties → choose Company (or Deal) properties → Create property → choose field type (Multi-line text / Dropdown select) → add options for the picklist → Create. Check the clone's connected user or app can edit the property.
3. **Create the Account Health Autopilot skill.** Fill the placeholders with the confirmed values, keep **Dry-run mode: ON**, and save it.
- **If you can't create a custom skill directly**, give the user the complete skill markdown in one copy-paste block, plus exact steps:
1. Open your clone's settings → **Skills** (or **Custom skills**).
2. Click **New skill** / **Add skill**.
3. Name it exactly **Account Health Autopilot**.
4. Paste the full block into the skill instructions field.
5. Read it through, then **Save**.
6. Tell me "saved" so I can verify it's attached.
(Menu names may differ slightly in your workspace.)
4. **Create the scheduled task.** Name: "Weekly Account Health Autopilot". Schedule: `{RUN_TIME}`, weekly. Action: "Run the Account Health Autopilot skill for the previous 7 days." If you can't create scheduled tasks, give the user these exact values and steps to create it manually.
5. **Report back** what succeeded and what failed, honestly, with exact error messages.
## 6. What the user must do
Give the user this list, with the how-to steps, and track which ones are done.
1. **Sign in to connections (OAuth).** For each connection marked ⚠️ or ❌ (Salesforce or HubSpot, Gmail or Outlook, Drive or OneDrive, Linear, Slack or Teams): open the clone's **Connections** / **Integrations** page → choose the app → **Connect** / **Sign in** → approve the requested permissions. Minimum permissions: CRM read on accounts, contacts, opportunities and cases plus **edit on the three fields**; email read + send; file storage read; tracker read; chat post. *I can't do this for you and I never need your password.*
2. **Share the transcripts folder with me.** Share `{TRANSCRIPTS_FOLDER}` with `{CLONE_INBOX}` (view access is enough), including subfolders.
3. **Check field-level permissions in the CRM.** The CRM user or app I connect as must be able to **edit** `{PAIN_POINTS_FIELD}`, `{HEALTH_FIELD}` and `{INTEGRATIONS_NEEDED_FIELD}`. Being able to edit the record is not enough if the fields are locked. A CRM admin may need to do this.
4. **Create the three fields (if I couldn't).** Follow the steps in section 5, then tell me "fields created" and I'll verify them.
5. **Tell me about validation rules.** Ask your CRM admin which fields must be filled before an account (or opportunity) can be saved, and confirm `{REQUIRED_FIELDS}`. I'll never fill those in by guessing; blocked records go on the report.
6. **Review the first dry run with someone who knows the accounts.** Then tell me "turn off dry run" when you're happy.
## 7. The Account Health Autopilot skill (save this in full)
Fill in the placeholders, then save as a skill named **Account Health Autopilot**. Don't shorten it.
~~~~markdown
# Account Health Autopilot
## Purpose
Every week, review the previous 7 days of customer activity across call transcripts,
email, CRM support cases and the ticket tracker; grade each in-scope account's health;
draft updates to three CRM fields; get approval; write the approved changes; and send
a weekly report.
## Settings
- Clone name: {CLONE_NAME}
- Clone inbox: {CLONE_INBOX}
- Company domains (internal): {YOUR_COMPANY_DOMAINS}
- Run time: {RUN_TIME} (lookback: previous 7 days)
- Current customer rule: {CUSTOMER_DEFINITION}
- Scope: {ACCOUNT_SCOPE}
- Write target: {WRITE_TARGET} (account or opportunity)
- Fields: {PAIN_POINTS_FIELD} (long text), {HEALTH_FIELD} (picklist), {INTEGRATIONS_NEEDED_FIELD} (long text)
- Health scale: {HEALTH_SCALE} (default below)
- Transcripts: {TRANSCRIPTS_FOLDER}
- Name mappings: {NAME_MAPPINGS}
- Exclusions: {EXCLUSIONS}
- Required fields (validation): {REQUIRED_FIELDS}
- Report to: {REPORT_RECIPIENTS} and/or {TEAM_CHANNEL}
- Dry-run mode: ON (no CRM writes until the user turns it off)
## Tools
Use the exact names from my skill catalog. Use whatever is connected; report what isn't. Use ONE CRM (Salesforce or HubSpot). On HubSpot there is no cases operator: use notes, tasks and engagements as the support signal.
| Purpose | Tool (exact catalog name) | Required | Access |
|---|---|---|---|
| Accounts/companies, opportunities/deals, cases (Salesforce) or engagements (HubSpot); write the 3 fields | Salesforce: `SalesforceAccountOperator`, `SalesforceOpportunityOperator`, `SalesforceCaseOperator`, `SalesforceActivityOperator`. HubSpot: `HubspotCompanyOperator`, `HubspotDealOperator`, `HubspotEngagementOperator` | Yes (one CRM) | Read; write ONLY the 3 fields, ONLY after approval |
| Search email by company name and domain; send report | `GoogleGmailOperator` or Outlook email operator | Yes | Read; send ONLY to report recipients |
| Read call transcripts | `GoogleDriveCoreOperator` or `Microsoft_OneDrive` folder, or `meeting_archive` (+ `call_archive` for phone calls) | Yes | Read-only |
| Run weekly | Scheduled task (`platform`) | Yes | Platform |
| Tickets and integration requests | `Linear_Operator` | Optional | Read-only |
| Post the report | Slack or Teams (clone messaging integration) | Optional | Post ONLY to {TEAM_CHANNEL} |
| Usage signals for silent risk | `GoogleSheets-Operator` or `Microsoft_Excel` usage export | Optional | Read-only |
## Health scale (default)
- Bright Green: expanding or about to expand; champion engaged; positive feedback; no serious open issues.
- Green: healthy and stable; normal engagement; issues are routine and being handled.
- Yellow: some concern: repeated issues, slower responses, key contact change, mild frustration.
- Orange: real risk: escalation, serious open issue, stalled rollout, budget/priority questions, or silent risk.
- Red: likely churn or downgrade without action: explicit dissatisfaction, evaluating competitors, renewal at risk.
- Black: churned, or churn / non-renewal notice given.
## Guardrails
- Never write to the CRM without explicit approval of this week's change table. If Dry-run mode is ON, never write at all.
- Write ONLY {PAIN_POINTS_FIELD}, {HEALTH_FIELD} and {INTEGRATIONS_NEEDED_FIELD}. Never touch any other field, record or object.
- Never guess or invent values for {REQUIRED_FIELDS} or any field to get past a validation rule. Mark the record "Blocked" and report what's missing.
- Never email or message customers. Only send to {REPORT_RECIPIENTS} / {TEAM_CHANNEL}.
- Every source lookup has exactly one status: "results", "no results" or "FAILED". Never count a failed lookup as zero activity.
- A failed source never makes an account look healthier. If key sources failed for an account, keep its current grade and say so.
- A quiet week alone never changes a grade.
- Only use facts you read in a source. Verify every keyword hit by reading it before using it.
- Skip {EXCLUSIONS} and anything not in {ACCOUNT_SCOPE}.
- Retry rule: if a tool call fails, retry ONCE. If it fails again, mark that source "FAILED" for that account (or for the whole run), continue with the rest, and report it.
- Never ask for or handle passwords or tokens.
## Step 1: Build the account list
1. From the CRM, list records in {ACCOUNT_SCOPE} that match {CUSTOMER_DEFINITION}.
2. Remove {EXCLUSIONS} (internal, test, referral/partner records).
3. For each record capture: name, ID, website/email domain(s), known contact emails, owner, current {HEALTH_FIELD}, current {PAIN_POINTS_FIELD}, current {INTEGRATIONS_NEEDED_FIELD}, and the values of {REQUIRED_FIELDS}.
4. Build search terms per account: official name, aliases, product names and parent/child links from {NAME_MAPPINGS}, and domains.
## Step 2: Sweep the previous 7 days (run the four sources in parallel)
For every account, record each source's status: results / no results / FAILED.
- Call transcripts: search {TRANSCRIPTS_FOLDER} (or `meeting_archive`, plus `call_archive` for phone calls) for files dated in the window that mention the account's search terms or have its attendees.
- Email: search by company name AND by domain AND by known contact addresses (contacts often use personal addresses such as gmail.com or outlook.com). Ignore threads only among {YOUR_COMPANY_DOMAINS} unless they clearly discuss the customer.
- CRM support signal: on Salesforce, list Cases on the account (and child accounts) created or updated in the window, ALL statuses (open and closed). On HubSpot, list notes, tasks and engagements on the company (and child companies) in the window. Then run a secondary text search of case subjects/descriptions (Salesforce) or note/task text (HubSpot) for the search terms to catch cases filed under the wrong account. Note misfiled cases in the report.
- Linear: search issues created or updated in the window that mention the account, its customer link, or its search terms. Note integration requests.
- Product usage (if a usage sheet is connected): activity trend for the window.
## Step 3: Verify the evidence
- Open and read each hit. Keep it only if it is really about this customer (watch for company names that are common words, people's names, or other companies with similar names).
- From verified hits, extract: issues and their severity, sentiment and direct quotes, upcoming changes (renewal, budget, leadership, migration, contract), integration requests, case IDs and ticket IDs, engagement (who joined calls, who replied).
## Step 4: Grade health
1. Start from the current grade.
2. Move the grade only when verified evidence supports it. Write a one-line reason citing the evidence.
3. A quiet week (no verified hits, all sources "no results") does NOT change the grade.
4. If one or more sources FAILED for this account, do not upgrade on missing evidence; keep the grade unless other evidence clearly supports a change, and note the failed sources.
5. Silent risk: flag the account if all sources returned "no results" for the last 7 days AND there are other signs of low use (no recent calls on record, no logins/usage if available, no replies to outreach). Silent risk is listed in the report and may justify Orange; it is never treated as healthy.
## Step 5: Draft the three fields
- {PAIN_POINTS_FIELD}: under ~1,500 characters. Most important fact first. Upcoming changes in ALL CAPS (e.g. "RENEWAL 2027-03-31; NEW VP OPERATIONS STARTING NOV"). Include short direct quotes and case/ticket IDs. Overwrite, but carry forward existing unique detail that is still true. List any existing detail you plan to drop.
- {HEALTH_FIELD}: one value from the scale, spelled exactly like the picklist.
- {INTEGRATIONS_NEEDED_FIELD}: never blank. List each requested integration with its ticket ID; flag requests with NO tracker ticket. If none: "None requested". Carry forward still-open requests.
- Check {REQUIRED_FIELDS} on the record. If any are empty, mark the record "Blocked: missing {field}" and don't plan a write.
## Step 6: Approval request
Send to {REPORT_RECIPIENTS} (and/or post to {TEAM_CHANNEL}) a change table:
| Account | Old grade → New grade | Reason | Pain points diff | Integrations diff | Flags |
|---|---|---|---|---|---|
Flags: DOWNGRADE, LOST DETAIL (with the text being dropped), BLOCKED (with missing fields), SOURCE FAILED, SILENT RISK.
Also list unchanged accounts in one line each. Ask: "Reply yes to write all, yes except [accounts], or no."
If Dry-run mode is ON, label the message "DRY RUN: no changes will be written" and stop after the report in Step 8.
## Step 7: Write approved changes
- Only after an explicit yes, and only for approved records.
- Write in batches of 2–4 records. After each batch, confirm the saved values by reading them back.
- Write only the three fields. If a save fails, retry once; if it fails again, record the exact error message verbatim and move on.
## Step 8: Weekly report
Send to {REPORT_RECIPIENTS} and/or post to {TEAM_CHANNEL}. Subject: "Account Health: week of {date}: {N} updated, {M} need attention".
1. Summary: accounts in scope, updated, unchanged, blocked, failed writes.
2. Health distribution: count per grade, and change since last week.
3. Movers: each upgrade and downgrade with the reason.
4. Silent risk: accounts with no activity and why it's a concern.
5. Failures: exact error messages per record; blocked records and missing fields.
6. Tracking gaps: integration requests without tickets, misfiled cases, sources that FAILED (per account or whole run), mappings that may be missing.
7. Source status: each source as worked / no results / FAILED (after retry).
~~~~
## 8. Test plan
Run this before relying on the weekly schedule. Ask the user to approve the test first. Never use real customers for write tests.
1. **Dry run on real data (no writes).** Run the skill with Dry-run mode ON for the full scope (or 5–10 accounts if the book is large). Nothing is written and no one but the user receives the report.
2. **User reviews grades** with someone who knows the accounts: are grades and reasons fair? Any false positives? Any missed escalations?
3. **Write test on a test record.** The user creates a **test account** (or opportunity) in the CRM, clearly named, e.g. "TEST: Health Autopilot", marked as a customer per `{CUSTOMER_DEFINITION}`, with `{REQUIRED_FIELDS}` filled. Optionally the user sends one email to the clone from a test address mentioning the test account, so there is something to find. With the user's approval, turn dry run off **for this test record only** and write it.
4. **Verify the checklist together:**
| Check | Pass? |
|---|---|
| Every source shows results / no results / FAILED (no source silently missing) | ☐ |
| A deliberately broken or unavailable source shows as FAILED, not "no results" | ☐ |
| Keyword hits were verified; no unrelated emails or transcripts cited | ☐ |
| `{EXCLUSIONS}` were skipped; `{NAME_MAPPINGS}` matched aliases correctly | ☐ |
| Quiet accounts kept their grade; silent-risk accounts were flagged | ☐ |
| Change table shows old → new grade, reason, diffs, and DOWNGRADE / LOST DETAIL / BLOCKED flags | ☐ |
| Dry run wrote **nothing** to the CRM | ☐ |
| Test record: only the three fields changed; values read back correctly; picklist value valid | ☐ |
| `{INTEGRATIONS_NEEDED_FIELD}` is not blank ("None requested" if none) | ☐ |
| Report arrived at `{REPORT_RECIPIENTS}` / `{TEAM_CHANNEL}` only | ☐ |
| **No email was sent to any customer or test contact** | ☐ |
5. Fix anything that failed, re-run, then the user **deletes the test record**. Dry-run mode stays ON until the user says "turn off dry run".
## 9. Final status checklist
When you finish, send the user a status summary in this format:
**✅ Done by me**
- [ ] Discovery table shared (including the three CRM fields)
- [ ] Placeholder values confirmed
- [ ] Required skills/operators attached: …
- [ ] Optional add-ons attached: …
- [ ] Three CRM fields created (or step-by-step instructions handed over)
- [ ] Account Health Autopilot skill created with Dry-run mode ON (or full text handed over for copy-paste)
- [ ] Scheduled task "Weekly Account Health Autopilot" created for `{RUN_TIME}`
- [ ] Dry run and test-record write completed; results: …
- [ ] (If the user wants it) Mentioned the prebuilt skill Weekly-Account-Health-Update as a quick-start alternative
**⏳ Waiting on you**
- [ ] Sign in to: …
- [ ] Share `{TRANSCRIPTS_FOLDER}` with `{CLONE_INBOX}`
- [ ] Grant the CRM integration user edit access to the three fields
- [ ] Create the three fields (if I couldn't)
- [ ] Confirm `{REQUIRED_FIELDS}` / validation rules
- [ ] Save the Account Health Autopilot skill (if I handed it over)
- [ ] Review the dry run, then tell me "turn off dry run"
- [ ] Delete the test record
**💡 Optional next steps**
- [ ] Connect Linear, Slack/Teams or a product usage sheet for better signals
- [ ] Refine `{HEALTH_SCALE}` definitions with your CS team
- [ ] Review `{NAME_MAPPINGS}` and `{EXCLUSIONS}` after the first month
- [ ] Add a "renewals in the next 90 days" section to the report
Requirements
Requirements: Account Health Autopilot
Version 1.1.0 · Last updated 2026-10-22 · Estimated setup time: 60–120 minutes
Use this checklist before you hand CLONE-INSTRUCTIONS.md to your clone. Your clone will also check most of this during discovery.
1. Required skills / operators
Use the exact operator names below. Your clone will report the names it finds in your catalog.
Skill names can differ slightly between orgs. Confirm the exact names in your skill catalog before saving the skill.
| # | Skill / operator | What it's used for | Notes |
|---|---|---|---|
| 1 | Salesforce: SalesforceAccountOperator, SalesforceOpportunityOperator, SalesforceCaseOperator, SalesforceActivityOperator or HubSpot: HubspotCompanyOperator, HubspotDealOperator, HubspotEngagementOperator | Build the account list, read the support signal, write the three health fields | Choose one CRM. Must support read and write. Salesforce: Cases are the support signal. HubSpot: no tickets/cases operator, so notes, tasks and engagements are the signal |
| 2 | Gmail (GoogleGmailOperator) or Outlook (email operator) | Search email by company name and domain; send the approval request and weekly report | Must be the clone's own inbox, or one shared with it |
| 3 | Transcript source: GoogleDriveCoreOperator or Microsoft_OneDrive folder, or meeting_archive (plus call_archive for phone calls) | Read call transcripts from the last 7 days | Folder is {TRANSCRIPTS_FOLDER}, or the clone's own archives |
| 4 | Scheduled task (platform) | Run the skill weekly at {RUN_TIME} | Platform feature; the clone may be able to create it |
2. Required connections and permissions
| Connection | Minimum permission | Why |
|---|---|---|
| CRM (Salesforce or HubSpot) | Read accounts/companies, opportunities/deals, cases (Salesforce) or engagements (HubSpot); edit {PAIN_POINTS_FIELD}, {HEALTH_FIELD}, {INTEGRATIONS_NEEDED_FIELD} | Scope, cases, and writing results. Field-level edit rights are required, not just record access |
| CRM (setup only, optional) | Admin / metadata rights to create custom fields | Only if you want the clone to create the three fields for you |
| Gmail or Outlook | Read + Send | Search activity; send the report to {REPORT_RECIPIENTS} only |
| Google Drive or OneDrive | View {TRANSCRIPTS_FOLDER} and subfolders | Read transcripts |
| Linear (if used) | Read issues | Open issues, integration requests |
| Slack or Teams (if used) | Post to {TEAM_CHANNEL} | Report delivery |
All connections are made by you through sign-in (OAuth). Your clone never needs your password.
3. Optional add-ons
| Add-on | Adds | Examples |
|---|---|---|
Linear (Linear_Operator) | Bugs, feature and integration requests per customer (strongly recommended) | Read-only |
| Slack or Microsoft Teams | Post the report and approval request to a team channel | Delivery only; cannot be read as a source |
Meeting archive (meeting_archive, call_archive) | The clone's own meeting and phone call transcripts as a source | Calls the clone attended |
Product usage export (GoogleSheets-Operator or Microsoft_Excel) | Logins and usage trends; a useful signal for silent risk | Only if you keep a usage export in a sheet |
| Weekly-Account-Health-Update (prebuilt skill) | Quick-start alternative, attached via platform | This card's custom skill gives full control instead |
Strongly recommended: Linear. Without it, integration requests can't be checked for tickets and bug activity is only seen through the CRM support signal.
The three CRM fields
| Field | Type | Values / limits |
|---|---|---|
{PAIN_POINTS_FIELD} | Long text area | Capacity 2,000+ characters; content kept under ~1,500 |
{HEALTH_FIELD} | Picklist (single select) | Bright Green, Green, Yellow, Orange, Red, Black (or your {HEALTH_SCALE}), spelled exactly the same in the skill |
{INTEGRATIONS_NEEDED_FIELD} | Long text area (or text 255+) | Never blank: "None requested" if none |
All three go on the object you choose as {WRITE_TARGET} (account or opportunity). The clone can give your CRM admin step-by-step instructions to create them (Salesforce or HubSpot).
Salesforce to HubSpot mapping
| Concept | Salesforce | HubSpot |
|---|---|---|
| Account / company | Account (SalesforceAccountOperator) | Company (HubspotCompanyOperator) |
| Opportunity / deal | Opportunity (SalesforceOpportunityOperator) | Deal (HubspotDealOperator) |
| Support signal | Case (SalesforceCaseOperator) | No tickets/cases operator: notes, tasks and engagements (HubspotEngagementOperator) |
| Activity / task | Task / Event (SalesforceActivityOperator) | Engagement: note, task, call (HubspotEngagementOperator) |
| Custom field | Custom field (Object Manager) | Custom property (Settings, Properties) |
| Long text type | Text Area (Long) | Multi-line text |
| Picklist type | Picklist | Dropdown select |
Validation rule ({REQUIRED_FIELDS}) | Validation rule / required field | Required property in pipeline or form |
| Field-level permission | Field-level security (profile / permission set) | Property edit permissions |
Current customer flag ({CUSTOMER_DEFINITION}) | e.g. Account Type = Customer | e.g. Lifecycle stage = Customer |
Field names vary by setup. Write your own rule for {CUSTOMER_DEFINITION} in plain words.
Google Workspace to Microsoft 365, Slack to Teams
| Concept | Google Workspace | Microsoft 365 |
|---|---|---|
Gmail (GoogleGmailOperator) | Outlook | |
| Transcript folder | Google Drive (GoogleDriveCoreOperator) | Microsoft_OneDrive folder |
| Report delivery | Slack | Microsoft Teams |
4. Data prerequisites
- Customer accounts have domains. Each account has a website or email domain filled in, and key contacts have email addresses.
- Clear customer flag. Current customers are consistently marked (your
{CUSTOMER_DEFINITION}). - Transcripts are saved somewhere the clone can read, with dates in the file name or metadata, in
{TRANSCRIPTS_FOLDER}(or the clone attends calls and keeps its own archive). - The three fields exist (or you're ready to create them) on
{WRITE_TARGET}. - Picklist values match
{HEALTH_SCALE}exactly. - Validation rules known. You know which fields must be filled for a save (
{REQUIRED_FIELDS}). - Name mappings drafted. A starting list of aliases, product names and parent/child links (
{NAME_MAPPINGS}). - Exclusions listed. Internal, test and referral/partner records (
{EXCLUSIONS}).
5. Roles and permissions
| Who | Needs to |
|---|---|
| Clone admin (owner of the clone in the Clone platform) | Attach skills/operators, approve the plan, save the skill, create/approve the scheduled task |
| CRM admin | Create the three fields (if the clone can't), grant the integration user field-level edit rights, confirm validation rules |
| Connection owner(s) | Complete OAuth sign-in for CRM, email, file storage, tracker, chat |
| Transcript folder owner | Share {TRANSCRIPTS_FOLDER} with the clone |
Weekly approver (usually a CS lead, in {REPORT_RECIPIENTS}) | Review the change table each week and reply yes / yes except / no |
| CS team / account owners | Sanity-check grades for their accounts, suggest name mappings and exclusions |
6. Estimated setup time
| Step | Time |
|---|---|
| Pre-flight check (this doc) | 10 min |
| Clone discovery + placeholders + plan | 15–20 min |
| Create CRM fields and permissions (if needed) | 10–30 min |
| Your sign-ins and folder sharing | 10–20 min |
| Save skill + scheduled task | 5–10 min |
| Dry run + review + test-record write | 20–30 min |
| Total | 60–120 min |
7. Pre-flight checklist
- I'm the clone admin (or have one available)
- Salesforce or HubSpot operators available in my catalog, with read and write support
- I (or a CRM admin) can grant edit access to three fields for the clone's CRM user
- Gmail or Outlook attached (or can be), with send permission
- Transcripts are in a folder I can share, or the clone has a meeting archive
- I can create scheduled tasks (or the clone can)
- (Optional) Linear operator (
Linear_Operator) available - (Optional) Slack or Teams connection for
{TEAM_CHANNEL} - I know my
{CUSTOMER_DEFINITION}and{ACCOUNT_SCOPE} - I've chosen
{WRITE_TARGET}(account or opportunity) - I have a first draft of
{NAME_MAPPINGS}and{EXCLUSIONS} - I know (or can find out)
{REQUIRED_FIELDS} - I've decided
{REPORT_RECIPIENTS}, the weekly approver and{RUN_TIME} - I can create a clearly labelled test record in the CRM for the write test
8. You're ready when…
- ✅ Every required item in section 1 is attached and its connection is signed in.
- ✅ The three fields exist on
{WRITE_TARGET}and the clone's CRM user can edit them. - ✅ The health picklist values match
{HEALTH_SCALE}exactly. - ✅ You have answers for all the placeholders in the README.
- ✅ Someone is named as the weekly approver.
- ✅ You've set aside ~30 minutes for the dry run and review.
Then download CLONE-INSTRUCTIONS.md and give it to your clone.
Was this use case helpful?
Thanks!