Scenario creator
Skill tough-tongue/toughtongue-skills/skills/scenario-creator
Create Tough Tongue AI practice scenarios (cold call, sales roleplay, coaching) via the ttai MCP server. Classifies the scenario type, applies type-specific authoring rules, gathers context from URLs, transcripts, or other connected tools, validates against a checklist, and creates the scenario with ttai:create_scenario. Use when the user says "create a scenario", "build a practice scenario", "make a roleplay for...", "I have a call in 30 minutes, help me rehearse", or provides a brief, company info, or call transcripts for scenario creation.From its SKILL.md
npx -y skills add tough-tongue/toughtongue-skills --skill scenario-creatorAssembled from the repository path, not quoted from the project. Check it against their README if it does not work.
One thing to look at
- 5 stars5 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.
SKILL.md
8.7 KB, as published. Nobody here has run it
Scenario Creator
Create production-ready Tough Tongue AI scenarios and push them live through the
ttai MCP server. Classify → load rules → gather context → draft → validate →
ttai:create_scenario → return the practice link.
Prerequisites
- The ttai MCP server must be connected. Tool references below use the
ttai:server prefix (e.g.ttai:create_scenario); some agents surface these asmcp__ttai__create_scenario. If the tools are missing, tell the user to install the Tough Tongue AI plugin or add the MCP server (see the repo README) — the client runs a browser OAuth login on first use.
Workflow
Step 1: Establish account context
Call ttai:list_organizations first.
- If the user belongs to organizations and the scenario is for a team, pass the
chosen
org_idon every subsequent tool call. - If no organizations, or the scenario is personal practice, omit
org_id. - If ambiguous, ask which context to create in.
Step 2: Classify scenario type
| Type | AI plays | Reference file |
|---|---|---|
| Cold Call / SDR | The outbound caller (user plays the lead) | references/cold-call.md |
| Sales Roleplay | The prospect (user practices selling) | references/sales-roleplay.md |
| Coaching | The trainer/mentor (teaches via exercises) | references/coaching.md |
| Demo | The AI SDR / product demo agent | references/demo.md |
| Other | Anything else (interview, support, negotiation) | references/scenario-fields.md only |
Decision signals:
- "cold call", "outbound", "lead qualification", "AI calls the customer", "SDR call" → Cold Call / SDR
- "practice selling", "objection handling", "prospect roleplay", "pitch practice", "prep me for this meeting" → Sales Roleplay
- "coach", "train my team", "teach", "onboarding", "framework" → Coaching
- "demo my product", "AI SDR demo", "show prospects", "browser demo", "slide demo", "product walkthrough" → Demo
If ambiguous, ask ONE question: "Should the AI play the caller/seller, the buyer/prospect, a coach/trainer, or a product demo agent?"
Read references/scenario-fields.md (always) plus the matching type reference.
For browser demos where the user wants a scripted, deterministic walkthrough ("pre-record the steps", "make the demo deterministic", "it should always click the same things"), load the browser-demo-builder skill after creating the scenario — it records the pre-recorded steps and sets up authenticated browsing.
Step 3: Gather context
- URLs provided (company site, product page, LinkedIn): fetch them. Extract
company name, product, target audience, key features, pricing model. Fold
into the
ai_instructionsCONTEXT section anduser_friendly_description. - Other connected tools: if the user references meetings, CRM records, call transcripts, or documents available through other MCP servers (calendar, Gong, Notion, ...), pull the relevant details and use them as scenario context — real names, real objections, real positioning beat invented ones.
- Pasted material (transcripts, briefs, positioning docs): mine it for the persona, objections, and vocabulary the scenario should reproduce.
Step 4: Clarifying questions (minimal)
Only ask when the answer is not obvious from the brief. Otherwise use defaults:
| Question | Ask when | Default |
|---|---|---|
| Language & voice | Locale unclear from context | en-US, defaults from references/scenario-fields.md |
| Call sub-type (cold call) | Warm/cold/follow-up unclear | Warm lead |
| Coaching pattern | Coaching type only | Pattern A (Situation-First) |
| Public or private | Team/enterprise use implied | is_public: true |
Step 5: Draft the scenario payload
Build a JSON payload matching the ttai:create_scenario input schema (load
the tool schema before calling). Author these fields, in order of importance:
name— short, descriptive display title.ai_model_config— set explicitly based on scenario type. See the "When to use which" table in references/scenario-fields.md. Cold call and slide-demo scenarios use Landmass/cascade-01 (requires TTS, STT, LLM fields). Sales roleplay uses Galaxy/medium. Coaching and browser-demo use Ocean/medium-stable.ai_instructions— the core field, 500+ words, structured with##sections per the type reference. For Landmass/cascade scenarios, also load references/cascade-tts.md and include the voice-pipeline blocks (output rules, transcription-error handling, natural speech style, SSML emotion tags if Cartesia).user_instructions— what the human should know before starting: situation → what to expect → how to succeed → tips.rubrik— evaluation criteria. CRITICAL: evaluate the correct party (cold call rubrics evaluate the LEAD; sales rubrics evaluate the REP; demo rubrics produce a buyer intelligence report).user_friendly_description— 1-2 public-facing sentences.strategy,tools_config,session_analysis,appearance— per the type reference and references/scenario-fields.md defaults.is_recording: truefor voice scenarios;is_publicper Step 4.
Do NOT set id — ttai:create_scenario rejects it (that is
ttai:update_scenario's job).
Step 6: Validate
Run the universal checklist, plus the type-specific checklist from the reference file:
-
name,ai_instructions,user_friendly_descriptionpresent -
ai_model_configset explicitly per the "When to use which" table -
ai_instructionsstructured with##sections; no unresolved placeholders except intentional{{ dynamic_vars }} -
tools_config.tools.end_sessionenabled withadd_to_system_prompt: true -
session_analysis.is_auto_analysis: trueandis_auto_submit: true -
rubrikevaluates the correct party, categories with weights - Cascade scenarios (Landmass): voice-pipeline blocks from
cascade-tts.md,
strategy.welcome_instructions(directive form, never quoted speech), conductor wrap-up message,appearance.language_codematches locale - Every dynamic variable
{{ var }}has a documented missing-value fallback
Step 7: Create
Call ttai:create_scenario with the payload (and org_id if applicable). On
validation errors, fix the named field and retry — do not strip features to
force it through.
Step 8: Return links
Report back with:
- Practice link:
https://app.toughtongueai.com/run/<scenario_id> - Embed link (if the user builds apps):
https://app.toughtongueai.com/embed/<scenario_id> - What was created (type, persona, evaluation focus) in 2-3 sentences.
- For private scenarios: mention
ttai:create_scenario_access_tokenmints 1-hour access tokens for sharing.
Quick path: ttai:generate_scenario
For a fast draft without hand-authoring, the ttai:generate_scenario tool
generates ai_instructions, user_instructions, and a description
server-side from a name and context document. Use it when the user wants
speed over control, then review the output and create via
ttai:create_scenario. Prefer full authoring for anything the user will run
with a team.
Pitfalls
- Never stack questions in voice-agent turns — one question per turn is the #1 authoring rule for natural calls.
- Never quote the opening line in
welcome_instructions— use directive form ("Start with: ... Then STOP and wait."). Quoted text is delivered robotically and restarts on interruption. - Wrong rubric target — a cold-call rubric that scores the AI caller instead of the lead produces useless reports.
- Missing end_session guidance — without explicit timing rules the agent either never hangs up or hangs up mid-conversation.
- The API token stays server-side; never embed
TTAI_PATin anything you generate for the user's app.
What ships with it: 7 files
64.5 KB alongside SKILL.md
agents/
- openai.yaml458 B
references/
- cascade-tts.md9.8 KB
- coaching.md11.4 KB
- cold-call.md14.3 KB
- demo.md9.0 KB
- sales-roleplay.md10.6 KB
- scenario-fields.md8.9 KB
Gives 0 of the 12 instructions most mcp tooling skills give
Counted across 780 of the 1,136 authors here whose files we hold, read 2026-09-06
- Use Zod for input validationin 34 of 780, across 21 files
- Use stdio for local clientsin 27 of 780, across 10 files
- Restart Claude Code after configurationin 26 of 780, across 23 files
- Verify MCP server connection before using toolsin 23 of 780, across 17 files
- Define input schemas for every toolin 20 of 780, across 11 files
- Use Streamable HTTP for remote clientsin 18 of 780, across 8 files
- Pin SDK version in package.jsonin 17 of 780, across 6 files
- Keep server logic independent of transportin 16 of 780, across 6 files
- Verify SDK methods against official documentationin 15 of 780, across 5 files
- Format evaluation results as an XML filein 15 of 780, across 12 files
- Test servers using the MCP Inspectorin 15 of 780, across 14 files
- Create ten complex and independent evaluation questionsin 14 of 780, across 11 files
Said here and by no other author read
- Call ttai:list_organizations first
- Read scenario-fields.md and the matching type reference
- Fetch URLs to extract company and product details
- Pull context from connected tools like CRM or transcripts
- Set ai_model_config explicitly based on scenario type
- Structure ai_instructions with ## sections
Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.