Clone Support
Use case

Transcript-to-Action Builder

Hand your clone a meeting transcript and it turns what you talked about into a plan, then builds, drafts and tracks the work.

The problem

Meetings end with a list of things to build, write and follow up on, and most of it stalls in a transcript nobody re-reads. This use case turns the conversation into owned, tracked, finished work the same day.

Transcript-to-Action Builder

Version 1.1.0 · Last updated 2026-10-22 · Difficulty: Beginner · Setup time: 20–40 minutes

Hand your clone a meeting or call transcript and say "help me build what we talked about." It summarizes the decisions, pulls out every action item, splits what it can do itself from what needs you, proposes a plan, and then gets to work after you approve.


1. Overview and value

Good meetings end with a list of things to do. Then the list sits in a transcript nobody re-reads. Someone was supposed to write the process doc, draft the follow-up email, build the little tracker page, create the CRM tasks and set up the automation. A week later, half of it hasn't started.

The Transcript-to-Action Builder closes that gap. When you give your clone a transcript, it:

  • summarizes the decisions and context (who, what, why, constraints),
  • extracts every action item into a table with owner, due date, dependency and the source quote,
  • sorts the actions: what the clone can do itself, what needs you, and what belongs to other people,
  • proposes a plan and asks a short batch of clarifying questions,
  • executes after your approval: drafts skills and instructions, builds apps or pages with Clone_Code, creates docs, sheets and slides, drafts emails, creates tasks in Salesforce or HubSpot (or issues in Linear), and writes generic step-by-step guides for tools it has no operator for,
  • tracks progress in a living plan and reports status as Done / Waiting on you / Next.

What you get:

BenefitWhat it looks like
Nothing falls through the cracksEvery action item is captured with its owner and source quote
Faster follow-throughDrafts, docs and simple tools are ready the same day as the meeting
Clear ownershipYou see exactly what the clone did, what's waiting on you and what's next
Safe by defaultEmails stay as drafts, plans need your "yes", nothing goes to customers on its own
Less reworkThe clone asks clarifying questions before building, and starts with the simplest version

Anything else (for example automation tools you run yourself) is not an integration. For a tool the clone has no operator for, it can only give you generic step-by-step instructions.


2. Who it's for

  • Ops leaders and managers who leave process meetings with a list of docs, checklists and automations to build.
  • Leadership who want decisions from planning or strategy meetings turned into owned, dated actions.
  • Customer Success Managers who leave customer calls with follow-ups, internal tasks and enablement material to create.
  • Sales reps and sales leaders who want call next steps turned into CRM tasks, draft follow-ups and simple collateral.
  • Anyone who has ever said "we should build a quick tool for that" in a meeting and never did.

It works on demand: you bring the transcript, the clone does the rest. An optional scheduled variant can pick up tagged transcripts automatically.

3. How it works

code
 ┌───────────────────────────────────────────────────────────────────┐
 │  You give {CLONE_NAME} a transcript:                              │
 │  pasted · upload · meeting_archive · call_archive · Drive/OneDrive │
 │  "Help me build what we talked about."                            │
 └───────────────────────────────┬───────────────────────────────────┘
                                 │
                                 ▼
 ┌───────────────────────────────────────────────────────────────────┐
 │  "Transcript to Action" skill                                     │
 │                                                                   │
 │  1. Read the transcript       ──►  split long ones into parts     │
 │  2. Summarize                 ──►  decisions · context ·          │
 │                                    constraints · open questions   │
 │  3. Extract action items      ──►  action · owner · due ·         │
 │                                    dependency · source quote      │
 │  4. Route each action         ──►  Clone can do / Needs you /     │
 │                                    Other people / Out of scope    │
 │  5. Propose plan + ask batched clarifying questions               │
 │                                                                   │
 │        ── waits for your "yes" ({APPROVAL_LEVEL}) ──              │
 │                                                                   │
 │  6. Execute                   ──►  skills · Clone_Code builds ·   │
 │                                    docs · email drafts · tasks ·  │
 │                                    step-by-step guides            │
 │  7. Update the plan           ──►  {PLAN_LOCATION}                │
 └───────────────────────────────┬───────────────────────────────────┘
                                 │
                                 ▼
 ┌───────────────────────────────────────────────────────────────────┐
 │  Status to you:  ✅ Done  ·  ⏳ Waiting on you  ·  ➡️ Next          │
 └───────────────────────────────────────────────────────────────────┘

 Optional: a scheduled task checks the meeting archive at {SCAN_TIME}
 for new transcripts containing {TRIGGER_KEYWORD} and starts at step 1
 (it still stops at step 5 and waits for your approval).

How the clone routes each action item

Every action item gets one category:

CategoryMeaningExample
Clone can doThe clone has the tool and the information to do it"Write up the new onboarding checklist"
Needs youThe clone can prepare it, but you must decide, sign in, send or click"Send the revised proposal to the customer" (clone drafts, you send)
Other peopleOwned by someone else in the meeting"Finance to confirm the budget" (clone can draft a request, the owner must agree)
Out of scopeNo tool for it, or it needs judgment the clone shouldn't make"Decide on the new pricing"

Action routing table

Type of actionHow the clone handles itToolNeeds approval?
Write a skill or clone instructionsDrafts the full markdown as one copy-paste blockNone (chat)Yes, and you read it before saving
Build an app, page, form, calculator or internal toolBuilds a simple first version (MVP), shares the link or files{CODING_SKILL_NAME} (default Clone_Code)Yes
Create a doc, checklist, SOP or summaryCreates the doc in {DEFAULT_DOC_LOCATION}GoogleDocsCoreOperator / Microsoft_Word (plus Drive / OneDrive)Yes
Email to internal people ({INTERNAL_DOMAINS})Drafts it; sends only if you say soGoogleGmailOperator or OutlookYes, per email
Email to external people (customers, prospects, partners)Draft only. Never sent without your explicit approval of that exact emailGoogleGmailOperator or OutlookYes, always per email
Create CRM tasksCreates them in {TASK_SYSTEM} with owner, due date and a link to the sourceSalesforceActivityOperator or HubspotEngagementOperatorYes
Create a Salesforce Case (support item)Creates the Case with a clear summary and sourceSalesforceCaseOperator (HubSpot: a note or task via HubspotEngagementOperator)Yes
Create an issueCreates it in Linear with owner, due date and sourceLinear_OperatorYes
Create a spreadsheet or slide deckBuilds the sheet, or a deck or reportGoogleSheets-Operator / Microsoft_Excel; GoogleSlidesOperator or Clone-Research-ReportYes
Post an internal updatePosts a short summary to the chosen channelSlack or Microsoft TeamsYes
Calendar follow-up meetingProposes times and drafts the inviteGoogleCalendarOperator or Outlook calendarYes
Research a question raised in the meetingResearches and summarizes with sourcesWeb researchCovered by plan approval
Image or diagramCreates a draft visualImage_OperatorCovered by plan approval
Set up a tool the clone has no operator for (admin settings, other software)Writes generic step-by-step instructions for you to followNone (chat or doc)No (nothing changes)
Decisions, pricing, contracts, hiring, legalLists them under "Needs you", does not actNoneNot applicable

4. What the clone does

Day to day:

  1. Reads the transcript you give it, from wherever it lives. Long transcripts are read in parts so nothing is skipped.
  2. Writes a short summary of decisions, context, constraints and open questions.
  3. Lists every action item in a table, with the quote or timestamp it came from, so you can check it.
  4. Sorts actions into Clone can do / Needs you / Other people / Out of scope.
  5. Proposes a plan and asks all its clarifying questions in one short, numbered batch.
  6. Executes after your "yes", starting with the simplest useful version of anything it builds.
  7. Keeps a living plan in {PLAN_LOCATION} and gives you a Done / Waiting on you / Next status after each work session.

What it never does:

  • Never sends email to customers, prospects or anyone outside {INTERNAL_DOMAINS} without your explicit approval of that exact email.
  • Never acts on items owned by other people without their consent (it can draft a note asking them).
  • Never makes decisions on pricing, contracts, legal, hiring or budget.
  • Never treats the transcript as fact for names, numbers and dates without flagging them for you to check.
  • Never saves a skill or instruction you haven't read.
  • Never asks for passwords, API keys or tokens.
  • Never puts internal-only remarks from the meeting into customer-facing drafts.

Example prompts you can use:

  • "Here's the transcript from my call with our ops team, help me build what we talked about."
  • "Only do the items assigned to me."
  • "Turn the decisions into a skill."
  • "Use the transcript from yesterday's 2 PM meeting in your archive."
  • "Just give me the action item table, don't do anything yet."
  • "Build the intake form we discussed with Clone_Code. Keep it simple."
  • "Create Salesforce or HubSpot tasks for every action with an owner and a date."
  • "What's the status of the plan from Tuesday's meeting?"

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 a few settings, 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 (5 min) Open REQUIREMENTS.md and run through the pre-flight checklist. The only hard requirements are a way to read transcripts (paste or upload works) and a doc or chat to hold the plan. Clone_Code, email, docs and Salesforce, HubSpot or Linear make it much more useful.

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 (3 min) The clone reports which skills/operators and connections it already has and which are missing.

Step 4: Answer the setting questions (5 min) See the table in section 6. Most have sensible defaults.

Step 5: Approve the plan (2 min) The clone lists exactly what it will attach and create. Say "yes" only when it looks right.

Step 6: Do your part (5–15 min) Things only you can do:

  • Complete sign-in (OAuth) for docs, email, Salesforce, HubSpot or Linear connections.
  • Share the folder for {DEFAULT_DOC_LOCATION} (and your transcript folder, if transcripts live in Drive or OneDrive) with the clone.
  • Decide your {APPROVAL_LEVEL}.

Step 7: Save the Transcript to Action skill (5 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 8: Run the test plan (10 min) Give the clone the sample transcript from CLONE-INSTRUCTIONS.md (made-up people and company, no real customers) and check the results against the checklist.

Step 9: Use it after your next real meeting Hand over the transcript and say "help me build what we talked about."

6. Placeholders to decide

PlaceholderWhat it meansExample
{CLONE_NAME}Your clone's display name"Ava"
{CLONE_INBOX}The clone's own email address (for sharing docs and folders)ava@yourcompany.com
{INTERNAL_DOMAINS}Your company's email domains. Everyone else is treated as externalyourcompany.com, yourcompany.io
{CODING_SKILL_NAME}The exact name of the coding skill in your catalog"Clone_Code" (default)
{DEFAULT_DOC_LOCATION}Where new docs are createdGoogle Drive folder "Meeting Actions" or OneDrive "Team/Actions"
{PLAN_LOCATION}Where the living plan is kept"A doc per meeting in {DEFAULT_DOC_LOCATION}" or "In this chat"
{TASK_SYSTEM}Where tasks are created"Salesforce tasks", "HubSpot tasks", "Linear", or "none" (list them in the plan only)
{APPROVAL_LEVEL}How often the clone asks before acting"approve plan once" or "approve each action" (default)
{TRIGGER_KEYWORD}(Optional scheduled variant) Word in a meeting title or transcript that means "process this""#actions"
{SCAN_TIME}(Optional scheduled variant) When to check the archive5:30 PM America/Chicago, Mon–Fri
{SUMMARY_RECIPIENT}(Optional scheduled variant) Who gets the "new transcript found" summaryyou@yourcompany.com

Note: even with "approve plan once", any email to an external person always needs its own approval.

7. What to expect day to day

  • After a meeting: give the clone the transcript (or tell it which meeting in its archive). Within a few minutes you get a summary, the action item table and a proposed plan with a short list of questions.
  • You answer and approve: reply with your answers and "yes" (or "yes, but skip 3 and 5").
  • The clone works: docs, drafts, tasks and Clone_Code builds appear. Simple items take minutes; a small app can take longer and may need a round of feedback.
  • Status updates: after each work session you get Done / Waiting on you / Next. The same status lives in {PLAN_LOCATION}.
  • Coming back later: ask "What's the status of the plan from the ops meeting?" and the clone picks up from the plan.
  • Optional scheduled variant: at {SCAN_TIME} the clone checks its meeting archive for new transcripts containing {TRIGGER_KEYWORD}, prepares the summary, action table and proposed plan, and sends them to {SUMMARY_RECIPIENT}. It does nothing else until you approve.

8. Customizing

Approval style. Switch between "approve each action" and "approve plan once" at any time ("From now on, approve the plan once and go").

Scope filters. Tell the clone what to focus on: "Only items assigned to me", "Only internal follow-ups", "Skip anything for the customer", "Only build things, don't create tasks".

Output formats. Change the summary length, add a "risks" section, or ask for the action table as a spreadsheet or doc instead of chat.

Task system. Point {TASK_SYSTEM} at Salesforce, HubSpot, Linear, or "none" if you prefer to keep everything in the plan doc.

Build style. Give Clone_Code standing preferences: "Single HTML page, no login", "Use our brand colors", "Always include a README".

Scheduled variant. Turn it on, change {TRIGGER_KEYWORD} or {SCAN_TIME}, or limit it to meetings you host.

9. Known gotchas

  • Transcripts contain errors. Speech-to-text gets names, numbers, dates and product names wrong ("15" vs "50", "Q3" vs "Q4", a product name spelled three ways). The clone flags these in a "Please verify" list. Check them before anything leaves the building.
  • Speaker attribution is often wrong. Transcripts mix up who said what, so owners in the action table may be wrong. Confirm owners before tasks are created.
  • Read every instruction before saving it into a skill. When the clone turns decisions into a skill, you're responsible for what that skill tells your clone to do. Read it fully, then save.
  • Keep internal-only remarks out of customer-facing output. Meetings include candid comments about customers, pricing or colleagues. The clone keeps those out of external drafts, but review every customer-facing draft yourself.
  • Name the coding skill explicitly. Say "use Clone_Code" (or your {CODING_SKILL_NAME}) when you want something built. Otherwise the clone may try other skills, write a doc about the tool instead of building it, or produce code in chat.
  • Don't overbuild. Start simple. "A dashboard" in a meeting usually means "a page with five numbers". The clone builds the smallest useful version (MVP) first and asks before adding more.
  • Sensitive information in transcripts. Transcripts can contain personal data, HR topics, salaries or confidential deal terms. Don't paste transcripts you aren't allowed to share, and tell the clone if parts are off-limits ("ignore the HR part").
  • Long transcripts may need splitting. Very long meetings may exceed what the clone reads at once. It processes them in parts and says so. If something seems missing, ask it to re-check a time range.
  • Actions owned by others need their consent. The clone won't create tasks for, or email on behalf of, other people without your approval, and it suggests checking with them first.
  • The clone can't click around in tools it has no operator for. For anything outside the supported tools (admin consoles, other software you run yourself), it writes generic step-by-step instructions instead.
  • Use exact skill/operator names as they appear in your skill catalog. Names can differ slightly between workspaces; the clone checks them during discovery.

10. FAQ

Where can the transcript come from? Pasted text, a file upload (TXT, DOCX, PDF, VTT/SRT), the clone's own meeting_archive or call_archive, or a doc in Google Drive / Google Docs or OneDrive / Word that's shared with the clone.

Does it work with my CRM or issue tracker? It works with Salesforce (tasks via SalesforceActivityOperator, Cases via SalesforceCaseOperator), HubSpot (notes and tasks via HubspotEngagementOperator) and Linear (Linear_Operator). Or set {TASK_SYSTEM} to "none".

Will the clone email my customers? No, not without your explicit approval of the exact email. External emails are always created as drafts first.

What can Clone_Code build? Simple apps, web pages, forms, calculators, scripts and internal tools (via Clone_Code). The clone starts with a minimal version and improves it with your feedback.

Can it set up tools it has no operator for? No. It only works with the tools listed in "supported". For anything else it writes a generic, numbered guide you (or your admin) can follow yourself.

What if the transcript has items for other people? They go in the "Other people" group. The clone can draft a message asking the owner to confirm, but it doesn't act for them.

Do I need the scheduled variant? No. Most people use this on demand. The scheduled variant is handy if you want a summary and plan waiting after every tagged meeting.

Is anything changed in my CRM during setup? No. Setup is read-only. Tasks are only created later, after you approve a plan.

11. Troubleshooting

SymptomLikely causeFix
Clone wrote a doc about the tool instead of building itCoding skill not named, or not attachedSay "use Clone_Code to build it"; check {CODING_SKILL_NAME} is attached
Wrong owner on an action itemSpeaker attribution error in the transcriptCorrect it in the action table; the clone updates the plan
Numbers or names in a draft are wrongTranscription errorCheck the "Please verify" list; tell the clone the correct values
Clone can't open the transcriptFile or folder not shared with {CLONE_INBOX}, or unsupported formatShare it, or paste the text / upload the file directly
Some action items are missingLong transcript read in parts, or item was implied rather than saidAsk "Re-check minutes 40–60 for action items" or add it yourself
No tasks were created{TASK_SYSTEM} is "none", or the Salesforce, HubSpot or Linear connection expiredSet {TASK_SYSTEM}; re-run the sign-in for the connection
"Tool unavailable" in the statusA tool call failed twiceCheck the connection; ask the clone to retry that item
Build is too complex or not what you meantRequest was vague; MVP rule not appliedAsk for "the simplest version that does X" and give one example
Scheduled variant found nothingKeyword missing from meeting title/transcript, or task pausedCheck {TRIGGER_KEYWORD} spelling; ask the clone to list its scheduled tasks
Internal remark showed up in a customer draftRemark not flagged as internal in the transcriptRemove it; tell the clone which topics are always internal

Version: 1.1.0 · Last updated: 2026-10-22 · Part of the Clone Use Case Library.

Paste these instructions into clone chat

# Clone Instructions: Transcript-to-Action Builder

> **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 **Transcript-to-Action Builder** use case for your user.

When setup is done, whenever the user gives you a meeting or call transcript and asks you to act on it, you will run a skill called **Transcript to Action** that:

1. reads the transcript (pasted, uploaded, from `meeting_archive` or `call_archive`, or from a shared Google Docs/Drive or Word/OneDrive doc),
2. summarizes decisions and context (who, what, why, constraints),
3. extracts every action item into a table (action, owner, due date, dependency, source quote/timestamp),
4. routes each action: Clone can do / Needs you / Other people / Out of scope,
5. proposes a plan and asks short, batched clarifying questions,
6. executes after approval (skills as copy-paste markdown, builds with `{CODING_SKILL_NAME}`, docs, sheets, slides, email drafts, tasks in `{TASK_SYSTEM}`, generic step-by-step guides for tools I have no operator for),
7. tracks progress in `{PLAN_LOCATION}` and reports status as **Done / Waiting on you / Next**.

Optionally, a scheduled task checks your meeting archive at `{SCAN_TIME}` for new transcripts containing `{TRIGGER_KEYWORD}` and prepares steps 1–5 only.

Your job right now is **setup only**: discover what's available, 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.

Be honest about your limits. If a tool isn't available to you 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, prospects or anyone outside the company during setup.** You may only send a test email to the user, and only after they approve it.
- **Read-only during setup.** Don't create, edit or delete anything in Salesforce, HubSpot, Linear, email or docs during setup, except the test items the user approves in section 8.
- **Use safe test data.** The test uses a made-up transcript. Never use a real customer or prospect transcript for testing.
- **Don't guess names.** Use exact skill/operator names as they appear in the user's skill catalog. Always refer to the coding skill by its exact name (default **Clone_Code**).

## 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 and whether its connection is active.

Look for:

| Need | Required? | Examples of what to look for |
|---|---|---|
| Transcript input | **Required** | Chat paste and file upload (built in) |
| Custom skill creation | **Required** | Ability to create a skill, or the user saves it by copy-paste |
| Coding skill | Strongly recommended | **Clone_Code** (or the workspace's exact name) |
| Docs / sheets / slides | Strongly recommended | `GoogleDocsCoreOperator`, `GoogleSheets-Operator`, `GoogleSlidesOperator`, `GoogleDriveCoreOperator`, or `Microsoft_Word`, `Microsoft_Excel`, `Microsoft_OneDrive` |
| Reports and decks | Optional | `Clone-Research-Report` |
| Email connection | Recommended | `GoogleGmailOperator` or the Outlook email operator (draft + send) |
| CRM operator | Optional | Salesforce: `SalesforceActivityOperator` (tasks), `SalesforceCaseOperator` (Cases). HubSpot: `HubspotEngagementOperator` (notes, tasks) |
| Issue tracker | Optional | `Linear_Operator` |
| Meeting and call archives | Optional | `meeting_archive`, `call_archive` |
| Calendar connection | Optional | `GoogleCalendarOperator` or the Outlook calendar operator (follow-up meetings) |
| Research skill | Optional | Web research |
| Image operator | Optional | `Image_Operator` |
| Chat | Optional | Slack or Microsoft Teams (post updates; delivery only) |
| Scheduled task | Optional | Only for the scheduled variant |

**Report the results to the user in a table like this:**

| Item | Status | Exact name in catalog | Notes |
|---|---|---|---|
| Transcript input | ✅ Connected / ⚠️ Attached, not signed in / ❌ Missing | … | … |
| Custom skill creation | … | … | … |
| Coding skill | … | … | … |
| Docs / storage | … | … | … |
| Email | … | … | … |
| CRM | … | … | … |
| Issue tracker (Linear) | … | … | … |
| Meeting / call archive | … | … | … |
| Calendar | … | … | … |
| Research | … | … | … |
| Image operator | … | … | … |
| Chat | … | … | … |
| Scheduled task | … | … | … |

If you can't check something (for example, there's no way to list connections), 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. **Clone name** (`{CLONE_NAME}`): *(default: my current name)*
> 2. **My inbox** (`{CLONE_INBOX}`): the address to share docs and folders with. *(I'll suggest the one I can see.)*
> 3. **Internal domains** (`{INTERNAL_DOMAINS}`): e.g. `yourcompany.com, yourcompany.io`. Everyone else counts as external.
> 4. **Coding skill name** (`{CODING_SKILL_NAME}`): *(default: Clone_Code)*
> 5. **Where to create docs** (`{DEFAULT_DOC_LOCATION}`): e.g. a Google Drive or OneDrive folder called "Meeting Actions".
> 6. **Where to keep the plan** (`{PLAN_LOCATION}`): *(default: one plan doc per meeting in the doc location; or "in chat")*
> 7. **Task system** (`{TASK_SYSTEM}`): Salesforce tasks, HubSpot tasks, Linear, or "none". *(default: none)*
> 8. **Approval level** (`{APPROVAL_LEVEL}`): "approve each action" or "approve plan once". *(default: approve each action. External emails always need their own approval.)*
> 9. **Scheduled variant?** Yes or no. If yes: trigger keyword (`{TRIGGER_KEYWORD}`, e.g. `#actions`), scan time with time zone (`{SCAN_TIME}`, e.g. 5:30 PM Mon–Fri) and who gets the summary (`{SUMMARY_RECIPIENT}`). *(default: no)*

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, e.g. Clone_Code, GoogleDocsCoreOperator]*.
> 2. Create the **Transcript to Action** skill using the text in section 7, with your values filled in.
> 3. *(Only if you chose the scheduled variant)* Create a scheduled task "Transcript Scan" that runs at `{SCAN_TIME}`.
> 4. Run the test in section 8 with a made-up transcript.
>
> **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. Confirm each with `describeOperator`. If an item needs a sign-in, tell the user (it goes on their list).
2. **Create the Transcript to Action skill.** Fill the placeholders with the confirmed values 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 **Transcript to Action**.
     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.)
3. **Create the scheduled task (optional variant only).** Name: "Transcript Scan". Schedule: `{SCAN_TIME}`. Action: "Run the Transcript to Action skill in scan mode: check my meeting archive for new transcripts containing {TRIGGER_KEYWORD}, prepare the summary, action table and proposed plan for each, send them to {SUMMARY_RECIPIENT}, and do nothing else until approved." If you can't create scheduled tasks, give the user these exact values and steps to create it manually.
4. **Report back** what succeeded and what failed, honestly.

## 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 ❌ (docs, email, Salesforce or HubSpot, Linear, calendar, Slack or Teams): open the clone's **Connections** / **Integrations** page → choose the app → **Connect** / **Sign in** → approve the requested permissions. *I can't do this for you and I never need your password.*
2. **Share folders with me.** Share `{DEFAULT_DOC_LOCATION}` with `{CLONE_INBOX}` with **edit** access so I can create docs there. If your transcripts live in Drive/OneDrive, share that folder with **view** access. I can't see anything that isn't shared with me.
3. **Check CRM / Linear permissions (if `{TASK_SYSTEM}` is not "none").** The connected account needs permission to create tasks (or Cases, or Linear issues). If your Salesforce, HubSpot or Linear admin manages this, ask them for "create tasks/activities" (or Case / issue create) access for the clone's connection.
4. **Save the skill** if I hand it over as copy-paste (steps in section 5). Read it first.
5. **Make transcripts available.** Either paste/upload them, or make sure I'm invited to meetings so they land in my meeting archive. For the scheduled variant, add `{TRIGGER_KEYWORD}` to the meeting title (or say it in the meeting).
6. **Know my limits.** For tools I have no operator for (admin consoles, other software you run yourself), I'll only write generic step-by-step instructions and you or your admin will click through them.

## 7. The Transcript to Action skill (save this in full)

Fill in the placeholders, then save as a skill named **Transcript to Action**. Don't shorten it.

~~~~markdown
# Transcript to Action

## Purpose
When my user gives me a meeting or call transcript and asks me to act on it
("help me build what we talked about"), turn it into a summary, a complete
action item table, a routed plan, and approved, finished work. Track progress
in a living plan and report Done / Waiting on you / Next.

## Settings
- Clone name: {CLONE_NAME}
- Clone inbox: {CLONE_INBOX}
- Internal domains: {INTERNAL_DOMAINS}
- Coding skill: {CODING_SKILL_NAME} (default: Clone_Code)
- Default doc location: {DEFAULT_DOC_LOCATION}
- Plan location: {PLAN_LOCATION}
- Task system: {TASK_SYSTEM} (Salesforce tasks, HubSpot tasks, Linear, or none)
- Approval level: {APPROVAL_LEVEL} (approve each action, or approve plan once)
- Scheduled variant (optional): keyword {TRIGGER_KEYWORD}, time {SCAN_TIME}, summary to {SUMMARY_RECIPIENT}

## Tools
Use the exact names from my skill catalog. Use whatever is connected; skip what isn't.

| Purpose | Tool (exact catalog name) | Required | Access |
|---|---|---|---|
| Read pasted or uploaded transcripts | Chat / file upload (built in) | Yes | Read |
| Build apps, pages, forms, tools, scripts | {CODING_SKILL_NAME} | Recommended | Create |
| Create docs, checklists, plan doc | `GoogleDocsCoreOperator` or `Microsoft_Word` (with `GoogleDriveCoreOperator` or `Microsoft_OneDrive`) | Recommended | Create + edit in {DEFAULT_DOC_LOCATION} only |
| Create spreadsheets (trackers, tables) | `GoogleSheets-Operator` or `Microsoft_Excel` | Optional | Create + edit in {DEFAULT_DOC_LOCATION} only |
| Create slide decks | `GoogleSlidesOperator` | Optional | Create in {DEFAULT_DOC_LOCATION} only |
| Create reports or decks from research | `Clone-Research-Report` | Optional | Create |
| Draft emails; send internal email when approved | `GoogleGmailOperator` or Outlook email operator | Recommended | Draft; send ONLY after approval |
| Create Salesforce tasks / activities | `SalesforceActivityOperator` | Optional | Create tasks only, after approval |
| Create Salesforce Cases | `SalesforceCaseOperator` | Optional | Create Cases only, after approval |
| Create HubSpot tasks / notes | `HubspotEngagementOperator` | Optional | Create tasks or notes only, after approval (HubSpot has no ticket operator) |
| Create Linear issues | `Linear_Operator` | Optional | Create issues only, after approval |
| Read past meeting transcripts | `meeting_archive` | Optional | Read-only |
| Read past phone calls | `call_archive` | Optional | Read-only |
| Read transcripts stored as docs | `GoogleDriveCoreOperator`, `GoogleDocsCoreOperator`, `Microsoft_OneDrive`, `Microsoft_Word` | Optional | Read-only |
| Propose follow-up meetings | `GoogleCalendarOperator` or Outlook calendar operator | Optional | Read; draft invites only after approval |
| Answer open questions from the meeting | Web research | Optional | Read |
| Diagrams and visuals | `Image_Operator` | Optional | Create image |
| Internal updates | Slack or Microsoft Teams (post via messaging integration) | Optional | Post only after approval; delivery only |

## Guardrails
- Plan first. Do nothing beyond Steps 1–5 until the user approves, per {APPROVAL_LEVEL}.
- External email: never send to anyone outside {INTERNAL_DOMAINS} without explicit approval of that exact email. Create drafts.
- Other people's actions: never create tasks for, assign work to, or message on behalf of other people without the user's approval. Suggest the user confirms with them first.
- Transcripts contain errors. Never treat names, numbers, dates, amounts or product names as confirmed. List doubtful ones under "Please verify" and use placeholders like [CONFIRM: amount] in drafts until confirmed.
- Customer-facing output: exclude internal-only remarks, opinions about people, pricing discussions, internal deal details, and other customers' information.
- Sensitive content: if the transcript includes personal data, HR, salary, legal or confidential topics, do not copy them into docs, tasks or drafts unless the user asks. Flag them.
- Never make decisions on pricing, contracts, legal, hiring or budget. Route them to "Needs you".
- Skills and instructions: draft them for the user to read. Remind the user to read every line before saving.
- Builds: always use {CODING_SKILL_NAME} by name for apps, pages, forms and tools. Build the simplest useful version (MVP) first. Ask before adding features.
- Never ask for or handle passwords, API keys or tokens. If a build needs a key, leave a clearly marked spot and tell the user how to add it.
- Retry rule: if a tool call fails, retry ONCE. If it fails again, mark that tool "unavailable", continue with the other actions, and report it in the status.

## Step 1: Get and read the transcript
- Source: pasted text, uploaded file, `meeting_archive` (find by date, title or attendees), `call_archive` (phone calls), or a shared Google Docs/Drive or Word/OneDrive doc.
- If I can't open it, say why (not shared, format, size) and ask the user to paste or upload it.
- If it is long, read it in parts (e.g. by 20–30 minute sections or by headings) and say "Read in N parts". Don't skip any part.
- Note the meeting title, date, attendees and which domains are internal ({INTERNAL_DOMAINS}) vs external.
- If the user gave a scope ("only my items", "only the decisions"), apply it from here on.

## Step 2: Summary
Write a short summary (under 200 words):
- Meeting: title, date, attendees (internal / external).
- Decisions: what was decided, by whom, and why.
- Context and constraints: goals, deadlines, budget limits, tools in use, dependencies.
- Open questions: things raised but not decided.
- Please verify: names, numbers, dates and product names that may be transcription errors.

## Step 3: Action item table
List EVERY action item, including implied ones ("someone should…", "we need to…"). Mark implied ones as "(implied)".

| # | Action | Owner | Due | Dependency | Source (quote or timestamp) |
|---|---|---|---|---|---|

- Owner: the person named; "Unassigned" if unclear; "(check)" if speaker attribution looks doubtful.
- Due: the date said, or "Not set". Convert relative dates ("next Friday") to a real date and mark "(check)".
- Dependency: another action number, a decision, access or a person.
- Source: a short exact quote or timestamp, so the user can check it.

## Step 4: Route each action
Give each action one category:
- **Clone can do**: I have the tool and enough information.
- **Needs you**: I can prepare it, but the user must decide, sign in, send, approve or click.
- **Other people**: owned by someone else; I can draft a request, but they must agree.
- **Out of scope**: no tool for it, or it needs a decision I shouldn't make.

Then pick how to handle it:

| Type of action | How I handle it | Tool | Needs approval? |
|---|---|---|---|
| Skill or clone instructions | Full markdown in one copy-paste block | Chat | Yes; user reads before saving |
| App, page, form, calculator, internal tool | Build an MVP, share the link/files | {CODING_SKILL_NAME} | Yes |
| Doc, checklist, SOP, summary | Create in {DEFAULT_DOC_LOCATION} | `GoogleDocsCoreOperator` / `Microsoft_Word` | Yes |
| Spreadsheet or tracker | Create the sheet | `GoogleSheets-Operator` / `Microsoft_Excel` | Yes |
| Slide deck | Create the deck | `GoogleSlidesOperator` | Yes |
| Report or research-based deck | Create the report or deck | `Clone-Research-Report` | Yes |
| Internal email | Draft; send only if approved | `GoogleGmailOperator` / Outlook | Yes, per email |
| External email | Draft only | `GoogleGmailOperator` / Outlook | Yes, always, per email |
| CRM task | Create in {TASK_SYSTEM} with owner, due date, link to plan | `SalesforceActivityOperator` / `HubspotEngagementOperator` | Yes |
| Support item | Salesforce: create a Case. HubSpot: create a note or task | `SalesforceCaseOperator` / `HubspotEngagementOperator` | Yes |
| Issue | Create a Linear issue with owner, due date, link to plan | `Linear_Operator` | Yes |
| Internal update | Post a short summary to the chosen channel | Slack / Microsoft Teams | Yes |
| Follow-up meeting | Propose times, draft invite | `GoogleCalendarOperator` / Outlook calendar | Yes |
| Research question | Research and summarize with sources | Web research | Covered by plan approval |
| Diagram or visual | Create a draft image | `Image_Operator` | Covered by plan approval |
| Tool I have no operator for (admin settings, other software) | Generic numbered step-by-step guide only | Chat or doc | No (nothing changes) |
| Decision, pricing, contract, legal, hiring, budget | List under "Needs you" | None | Not applicable |

If {TASK_SYSTEM} is "none", list tasks in the plan only.

## Step 5: Proposed plan and clarifying questions
Send ONE message with:
1. The summary (Step 2) and action table (Step 3).
2. The plan: numbered list grouped by Clone can do / Needs you / Other people / Out of scope. For each item: what I'll produce, which tool, and whether it needs approval.
3. Clarifying questions: at most 7, short, numbered, batched in one list. Offer a default for each ("If you don't say, I'll…"). Include any "Please verify" items.
4. The ask: "Reply yes to start, or tell me what to change (e.g. 'yes, skip 3')."
Stop here and wait.

## Step 6: Execute after approval
- Follow {APPROVAL_LEVEL}: if "approve each action", confirm each item before doing it; if "approve plan once", do all approved items, but still get separate approval for every external email.
- Work in plan order, simplest and most unblocking items first.
- Skills/instructions: write a complete skill (Purpose, Settings, Tools, Guardrails, Steps, Output) in one copy-paste block. Add: "Read every line before you save this."
- Builds: say "Using {CODING_SKILL_NAME} to build…", build the MVP, then share what it does, how to open it, and what's not included yet.
- Docs: create in {DEFAULT_DOC_LOCATION}, share the link.
- Emails: create drafts; show recipients, subject and body; send only internal ones the user approved.
- Tasks: create in {TASK_SYSTEM} with a clear title, owner, due date and a link or note pointing to the plan. Salesforce tasks use `SalesforceActivityOperator`, Cases use `SalesforceCaseOperator`; HubSpot tasks and notes use `HubspotEngagementOperator`; issues use `Linear_Operator`.
- Tools I have no operator for: generic numbered steps only (what to open, what to type, how to test it). Say that menus may differ and that I can't do it for them.
- If something fails twice, mark it "Blocked: tool unavailable" and move on.

## Step 7: Track progress and report status
- Keep a living checklist in {PLAN_LOCATION}: meeting name and date, each action with category, status (Not started / In progress / Done / Blocked / Waiting on you), link to output, and last updated date.
- After each work session, and whenever the user asks "status?", reply in this format:

**Plan: {meeting title} ({date})**

**✅ Done**
- [x] #1 Onboarding checklist doc: [link]

**⏳ Waiting on you**
- [ ] #4 Approve the draft email to the customer (draft ready)
- [ ] #6 Confirm the go-live date ("June 15" in the transcript)

**➡️ Next**
- [ ] #2 Build the intake form with {CODING_SKILL_NAME} (MVP)

**Blocked / unavailable**: tool and what happened, or "None".

## Scan mode (scheduled variant only)
At {SCAN_TIME}, check my meeting archive for transcripts since the last scan whose title or text contains {TRIGGER_KEYWORD}. For each, do Steps 1–5 and send the result to {SUMMARY_RECIPIENT} only. Do not execute anything. If none are found, send nothing (or one line, if the user asked for it).
~~~~

## 8. Test plan

Run this before using it on real meetings. Ask the user to approve the test first. Use the made-up transcript below. **Never use a real customer or prospect transcript for testing.**

1. **Paste this sample transcript** into the chat (all names and companies are made up):

```
Internal ops sync, made-up example. Attendees: Sam (ops lead), Jordan (support), Riley (finance).
[00:01] Sam: We decided to move vendor requests to one intake form instead of email.
[00:03] Jordan: Can we get a simple form with name, vendor, amount and reason?
[00:04] Sam: Yes. Let's also write a one-page checklist for approvers.
[00:06] Riley: Anything over fifteen hundred dollars needs finance sign-off. I'll confirm the exact limit by Friday.
[00:08] Sam: Someone should email the team about the change once the form is ready.
[00:09] Jordan: I'll look into a way to post new requests to our chat channel.
[00:10] Sam: Also we're not happy with how slow Vendor X has been, but keep that between us.
```

2. **Say:** "Help me build what we talked about. Use {CODING_SKILL_NAME} for the form."
3. **Approve only safe items:** the form MVP, the checklist doc, an internal email **draft** to the user only, and the generic step-by-step guide for the chat-channel idea. If `{TASK_SYSTEM}` is set, approve **one** test task assigned to the user, titled "TEST: delete me".
4. **Verify the checklist together:**

| Check | Pass? |
|---|---|
| Summary lists the decision (intake form) and the constraint (finance sign-off over a limit) | ☐ |
| Action table has all items, including the implied email ("someone should"), with owners and source quotes | ☐ |
| "Fifteen hundred dollars" and "by Friday" appear under "Please verify" | ☐ |
| Actions are routed correctly (Riley's limit = Other people; chat-channel idea = generic step-by-step guide) | ☐ |
| Clarifying questions came in one short, numbered batch, and nothing happened before "yes" | ☐ |
| The form was built with **{CODING_SKILL_NAME}** (named in the reply) and is a simple MVP | ☐ |
| The checklist doc was created in `{DEFAULT_DOC_LOCATION}` | ☐ |
| The email is a **draft** and was not sent | ☐ |
| The remark about Vendor X does not appear in any draft or doc | ☐ |
| (If set) One test task was created in `{TASK_SYSTEM}` | ☐ |
| Plan exists in `{PLAN_LOCATION}` and status came back as Done / Waiting on you / Next | ☐ |
| **No email was sent to anyone** | ☐ |

5. Fix anything that failed and re-run. Then **clean up**: delete the test doc, the draft email, the test build (if hosted) and the "TEST: delete me" task. I can delete items I created if I have permission; otherwise I'll tell you exactly what to delete.

## 9. Final status checklist

When you finish, send the user a status summary in this format:

**✅ Done by me**
- [ ] Discovery table shared
- [ ] Placeholder values confirmed
- [ ] Skills/operators attached: …
- [ ] Transcript to Action skill created (or full text handed over for copy-paste)
- [ ] (Optional) Scheduled task "Transcript Scan" created for `{SCAN_TIME}`
- [ ] Test run completed; results: …

**⏳ Waiting on you**
- [ ] Sign in to: …
- [ ] Share `{DEFAULT_DOC_LOCATION}` (edit) and transcript folder (view) with `{CLONE_INBOX}`
- [ ] Confirm task-create permission in `{TASK_SYSTEM}` (if used)
- [ ] Save the Transcript to Action skill (if I handed it over), after reading it
- [ ] Clean up test items: …

**💡 Optional next steps**
- [ ] Turn on the scheduled variant with `{TRIGGER_KEYWORD}`
- [ ] Connect Salesforce, HubSpot or Linear so I can create tasks
- [ ] Connect Slack or Teams for internal updates
- [ ] Give me standing build preferences (brand colors, single page, no login)
- [ ] Try it on your next real meeting: "Here's the transcript, help me build what we talked about."

Requirements

Requirements: Transcript-to-Action Builder

Version 1.1.0 · Last updated 2026-10-22 · Estimated setup time: 20–40 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

Names below are the exact operator and skill names. Confirm them against your skill catalog (your clone will report what it finds).

#Skill / operatorWhat it's used forNotes
1Transcript inputRead the transcript you paste or uploadBuilt in. meeting_archive, call_archive and Drive/OneDrive docs are optional extras
2Custom skill (Transcript to Action)The instructions the clone follows every timeThe clone creates it, or you save it by copy-paste
3Clone_Code (coding skill)Build apps, pages, forms, calculators and small toolsStrongly recommended. Always name it explicitly when asking for a build
4GoogleDocsCoreOperator (with GoogleDriveCoreOperator) or Microsoft_Word (with Microsoft_OneDrive)Create docs, checklists and the living planStrongly recommended
5GoogleGmailOperator or the Outlook email operatorDraft follow-up emails; send internal ones you approveRecommended

Skill names can differ slightly between orgs. Confirm the exact names in your skill catalog before saving the skill.

Without 3–5 the clone can still summarize, extract actions, write skills and give step-by-step guides in chat. It just can't build, file docs or draft emails for you.

Tools without an operator are not integrations. For those the clone only writes generic step-by-step instructions.

2. Required connections and permissions

ConnectionMinimum permissionWhy
Docs / storage (Google or Microsoft 365)Edit in {DEFAULT_DOC_LOCATION} onlyCreate docs, sheets, slides and the plan
Docs / storage (transcripts, if stored there)View the transcript folderRead transcripts
Email (Gmail or Outlook)Read + Draft (+ Send for approved internal emails)Draft follow-ups; never send externally without approval
Salesforce (if used as {TASK_SYSTEM})Read + Create tasks (SalesforceActivityOperator); Create Cases (SalesforceCaseOperator) if you want CasesCreate approved tasks and Cases. No edit/delete needed
HubSpot (if used as {TASK_SYSTEM})Read + Create tasks/notes (HubspotEngagementOperator)Create approved tasks and notes
Linear (if used)Read + Create issues (Linear_Operator)Create approved issues
Calendar (if used)Read + create draft invitesPropose follow-up meetings
Slack or Teams (if used)Post in chosen channelsInternal updates, only after approval

All connections are made by you through sign-in (OAuth). Your clone never needs your password.

3. Optional add-ons

Add-onAddsExact names
Meeting and call archivesPick a transcript by meeting name/date; enables the scheduled variantmeeting_archive, call_archive
Sheets and slidesTrackers, tables, decksGoogleSheets-Operator, GoogleSlidesOperator, Microsoft_Excel
Reports and decksResearch-based reportsClone-Research-Report
SalesforceFollow-up tasks; support CasesSalesforceActivityOperator, SalesforceCaseOperator
HubSpotFollow-up tasks and notesHubspotEngagementOperator
LinearIssues for product, support or ops workLinear_Operator
Calendar connectionPropose and draft follow-up meetingsGoogleCalendarOperator, Outlook calendar operator
ResearchAnswer open questions raised in the meeting, with sourcesWeb research
Image operatorDiagrams, process visuals, simple graphicsImage_Operator
Slack or TeamsPost approved internal updatesMessaging integration
Scheduled taskScan the archive for {TRIGGER_KEYWORD} at {SCAN_TIME}Platform feature

CRM concept mapping (Salesforce ⇄ HubSpot)

Generic conceptSalesforceHubSpot
Account / companyAccountCompany
ContactContactContact
LeadLeadContact (Lifecycle stage = Lead)
Opportunity / dealOpportunityDeal
Support itemCase (SalesforceCaseOperator)Note or task (HubspotEngagementOperator; no ticket operator)
Task / activity (what the clone creates)Task (SalesforceActivityOperator)Task (HubspotEngagementOperator)
Custom fieldsCustom field (__c)Custom property

Field names vary by setup. The clone only creates tasks, Cases and notes; it doesn't edit accounts, deals or custom fields.

Google Workspace ⇄ Microsoft 365

ConceptGoogle WorkspaceMicrosoft 365
EmailGoogleGmailOperator (drafts)Outlook email operator (drafts)
CalendarGoogleCalendarOperatorOutlook calendar operator
DocsGoogleDocsCoreOperatorMicrosoft_Word
SheetsGoogleSheets-OperatorMicrosoft_Excel
SlidesGoogleSlidesOperator(use Clone-Research-Report for decks)
StorageGoogleDriveCoreOperatorMicrosoft_OneDrive

Slack ⇄ Teams

ConceptSlackMicrosoft Teams
Team spaceChannelTeam / Channel
Direct messageDMChat

Tools without an operator (instructions only)

For admin consoles or other software you run yourself, the clone can only write generic numbered instructions. It can't click through them, and they are not integrations.

4. Data prerequisites

  • You can get transcripts of your meetings (from your meeting tool, the clone's archive, or a notes app) as text, DOCX, PDF or VTT/SRT.
  • You're allowed to share them with the clone (check confidentiality, HR or legal restrictions).
  • A folder for outputs exists ({DEFAULT_DOC_LOCATION}) and can be shared with {CLONE_INBOX}.
  • You know your internal domains ({INTERNAL_DOMAINS}) so the clone can tell internal from external people.
  • (If creating tasks) Owners exist as users in Salesforce, HubSpot or Linear, so tasks can be assigned.
  • (Scheduled variant) The clone attends the meetings you want scanned, and you use {TRIGGER_KEYWORD} in titles.

5. Roles and permissions

WhoNeeds to
Clone admin (owner of the clone in the Clone platform)Attach skills/operators, approve the plan, save the Transcript to Action skill, create the optional scheduled task
Connection owner(s)Complete OAuth sign-in for docs, email, Salesforce, HubSpot, Linear, calendar, Slack or Teams
Salesforce / HubSpot / Linear adminGrant the clone's connection permission to create tasks, Cases or issues (if used)
Folder ownerShare {DEFAULT_DOC_LOCATION} (edit) and transcript folder (view) with the clone
Day-to-day userHand over transcripts, answer questions, approve plans and each external email, verify names/numbers/dates
Other action ownersAgree before work is assigned to them or sent in their name

6. Estimated setup time

StepTime
Pre-flight check (this doc)5 min
Clone discovery + placeholders + plan5–10 min
Your sign-ins and folder sharing5–10 min
Save skill (+ optional scheduled task)5 min
Test run with the sample transcript10 min
Total20–40 min

7. Pre-flight checklist

  • I'm the clone admin (or have one available)
  • I can paste or upload a transcript to my clone
  • Clone_Code is available in my catalog
  • GoogleDocsCoreOperator or Microsoft_Word is available and I can sign in
  • GoogleGmailOperator or Outlook is available (for drafts)
  • I've picked {DEFAULT_DOC_LOCATION} and {PLAN_LOCATION}
  • I know my {INTERNAL_DOMAINS}
  • I've decided {TASK_SYSTEM} (Salesforce, HubSpot, Linear, or none)
  • I've decided {APPROVAL_LEVEL}
  • (Optional) Salesforce, HubSpot or Linear operator available with create permission
  • (Optional) Scheduled variant: {TRIGGER_KEYWORD}, {SCAN_TIME}, {SUMMARY_RECIPIENT} decided
  • I'll use the made-up sample transcript for testing, not a real customer meeting

8. You're ready when…

  • ✅ Your clone can read a transcript you paste or upload.
  • ✅ Clone_Code and a docs operator are attached (or you've accepted chat-only output).
  • ✅ You have answers for the placeholders (or are happy with the defaults).
  • ✅ {DEFAULT_DOC_LOCATION} is shared with the clone.
  • ✅ You know that external emails always stay drafts until you approve them.
  • ✅ You've set aside ~10 minutes for the test run.

Then download CLONE-INSTRUCTIONS.md and give it to your clone.

Was this use case helpful?