Build personality models of colleagues, clients, friends, or family members and get AI-powered communication strategies. Use this skill whenever the user wants to: understand someone's personality, predict how someone will react, get advice on communicating with a difficult person, prepare for a tough conversation, navigate office politics, resolve interpersonal conflict, write a strategic message to someone specific, or simulate a scenario with a specific person. Also trigger when the user m...
Install via CLI
openskills install snowyowlmia/persona-compass---
name: persona-compass
description: >
Build personality models of colleagues, clients, friends, or family members and get
AI-powered communication strategies. Use this skill whenever the user wants to:
understand someone's personality, predict how someone will react, get advice on
communicating with a difficult person, prepare for a tough conversation, navigate
office politics, resolve interpersonal conflict, write a strategic message to
someone specific, or simulate a scenario with a specific person. Also trigger when
the user mentions: "how do I deal with", "how should I talk to", "what would X do if",
"help me communicate with", "prepare me for a conversation with", MBTI, DISC,
personality type, difficult coworker, toxic boss, or relationship dynamics.
Supports both English and Chinese (中英双语). 职场读心术,AI 帮你搞定难搞的人。
version: 1.1.0
user-invocable: true
allowed-tools: Read, Write, Edit, Bash
---
# Persona Compass 🧭
> Navigate people like you navigate code.
> 职场读心术,AI 帮你搞定难搞的人。
Build a personality model → Predict behavior → Get actionable communication strategies.
**This is a communication optimization tool, not a manipulation tool.**
The goal is mutual understanding, reduced friction, and win-win outcomes.
---
## Trigger Conditions
Activate when the user says any of:
- `/persona-compass` or `/pc`
- "帮我分析一个人" / "帮我搞定某某"
- "How do I deal with [person]"
- "Help me communicate with [person]"
- "What would [person] do if..."
- "Prepare me for a conversation with [person]"
- Any reference to an existing persona profile by name/slug
Enter **query mode** when a persona already exists and user asks:
- A scenario question ("如果我跟他说...他会怎么反应?")
- A strategy request ("帮我写封邮件给他")
- A simulation ("模拟一下我跟他谈加薪")
Enter **evolution mode** when user says:
- "他不会这样" / "That's not right" / "Update [persona]"
- "我有新的信息" / "I observed something new"
---
## Language Detection
Detect the user's language from their first message.
- Chinese input → respond in Chinese throughout
- English input → respond in English throughout
- Mixed → follow the dominant language, keep technical terms in English
---
## Privacy & Codename System
**All persona data uses codenames, never real names in visible locations.**
When creating a persona, ask the user to assign a codename (e.g., "alpha", "falcon",
"coffee"). If they don't choose one, auto-generate a random codename.
**Rules:**
- File/directory names use codenames only: `personas/alpha/`, never `personas/jason-park/`
- Commands use codenames: `/pc alpha`, never `/pc jason-park`
- Output headers use codenames: "Strategy for Alpha", never "Strategy for Jason"
- Real names are stored ONLY inside persona.md content, never in filenames or commands
- If someone glances at the user's screen, they see generic professional-looking output
**Why:** Users will be using this at work, possibly on shared screens or monitored
devices. If a coworker sees "How to handle Jason's credit-stealing" on screen,
the relationship is destroyed. Codenames prevent this.
**Recommended usage environments (include in first-time user guidance):**
- Best: Claude mobile app (private, personal device)
- Good: Claude.ai in incognito/private browser tab
- OK: Claude Code terminal (but close after use)
- Risky: Shared/projected screen, company-monitored devices
---
## Platform Modes
This skill operates in two modes depending on the environment:
### File Mode (Claude Code / Claude.ai with Code Execution)
- Persona data saved to `personas/{codename}/` directory
- Full persistence across sessions
- Relationship map stored in `personas/_network/map.json`
- Version history and accuracy tracking in meta.json
### Conversation Mode (Claude.ai without Code Execution / Mobile App)
- Persona data lives in the conversation context and Claude's memory
- No file system required — works purely through chat
- User can export persona as a text block to save manually
- When user returns and mentions a codename, check Claude's memory first
- If memory has the persona data, load and use it directly
- If not, ask: "I don't have [codename]'s profile loaded. Can you give me
a quick refresher? Or paste their profile if you saved it."
**Auto-detect:** If file system tools are available, use File Mode.
If not, gracefully fall back to Conversation Mode. Never error out
because files aren't available.
---
## Quick Commands (Micro-Interactions)
These commands are designed for 5-30 second interactions — the "daily vitamin"
that builds habitual usage. They return SHORT outputs, not full analyses.
### `/pc prep [codename]`
**Pre-meeting cheat sheet.** Output exactly:
- 3 lines: their communication style reminder
- 2 lines: what to watch for in this interaction
- 1 line: opening move recommendation
Total output: 6 lines max. No persona card. No strategy analysis.
Example output:
```
PREP: Alpha (D/I type)
Style: Direct, bottom-line first. Don't hedge or over-explain.
Watch: He may steer toward quarterly review — redirect to your agenda first.
Watch: If he says "let me handle it," that means he's claiming ownership.
Open with: "I want to align on [your topic] before we discuss anything else."
```
### `/pc tone [codename]`
**5-second tone check before sending a message.** Output exactly:
- 1 line: tone instruction
Example: `Alpha: Direct. Lead with data. No small talk. No emoji.`
### `/pc radar`
**Weekly relationship scan.** Output exactly:
- List of saved personas with last interaction date
- Any pending follow-ups or predictions to verify
- 1 suggested action for the coming week
Total output: 10 lines max.
### `/pc draft [codename] "[context]"`
**Generate ONLY the message draft, nothing else.** No strategy analysis.
No persona card summary. Just the ready-to-copy message.
- Output 2-3 variants, each labeled with what it optimizes for
- Specify the channel (Slack / email / talking points)
- If email, include subject line
- Keep each variant under 100 words for Slack, 200 for email
Example:
```
DRAFT for Alpha — pushing back on timeline
VARIANT A (firm but collaborative):
"Hey [name] — looked at the timeline for X. At current scope, we're
looking at [date], not [original date]. Two options: we cut [feature]
to hit the original date, or we extend by 2 weeks for the full scope.
What's your preference?"
VARIANT B (create urgency):
"Quick flag on X — timeline risk. Can we do 15 min today to align
on scope vs deadline tradeoff? I have options ready."
```
### `/pc list`
**Show all saved personas.** For when the user forgets which codename maps to which person.
- **Claude Code**: Read all `personas/*/SKILL.md` files, extract codename + role + relationship
- **Memory Mode**: Scan Claude Memory for all `PERSONA_COMPASS:` entries
Output format — codename + role + relationship hint only. No real names:
```
Your saved personas:
🐌 sloth — PM, controls your sprint | D+C type
🦊 fox — CTO, 2 levels above you | D type
🐻 bear — peer engineer, competes for same projects | C type
Type /pc prep {codename} to use a profile.
```
If user asks **"who is sloth again?"** or **"remind me what fox is about"**:
→ Output 2 lines only. Role + one defining trait. No full card.
```
sloth: Your PM who controls sprint prioritization.
Key trait: Delays instead of refusing. Never says no directly.
```
---
### Step 1: Quick Start (3 tiers)
Offer three input modes based on how much the user knows:
```
How well do you know this person?
[A] Quick Sketch (30 seconds)
Name + role + 3 personality adjectives
→ Generates a draft persona from archetypes
[B] Standard Profile (5 minutes)
Guided interview: 8 key questions
→ Generates a data-backed persona
[C] Deep Analysis (10+ minutes)
Paste chat logs, describe incidents, provide context
→ Generates a high-fidelity persona with prediction confidence scores
```
### Step 2: Information Collection
**For Quick Sketch [A]**, ask only:
1. **Name/alias** (required)
2. **Role & relationship** (e.g., "PM on my team", "my skip-level manager", "my spouse")
3. **Three words** that describe them (e.g., "controlling, data-driven, insecure")
**For Standard Profile [B]**, use the guided interview in `${SKILL_DIR}/prompts/intake.md`.
Core questions cover:
- Communication style (verbose vs terse, direct vs indirect)
- Decision-making pattern (data-driven vs gut-feel vs consensus)
- Conflict behavior (fight vs flight vs freeze vs negotiate)
- Motivation drivers (what do they care about most?)
- Stress response (what happens under pressure?)
- Trust signals (how do they build/lose trust?)
- Power dynamics (how do they relate to authority?)
- Known personality indicators (MBTI, DISC, zodiac — optional but useful as priors)
**For Deep Analysis [C]**, additionally accept:
- Pasted chat logs (Slack, Teams, WeChat, email)
- Described incidents ("Last week when X happened, he did Y")
- Work artifacts (how they write docs, run meetings, give feedback)
- Third-party observations ("Our mutual friend says he's...")
Read the full question sequences from `${SKILL_DIR}/prompts/intake.md`.
### Step 3: Personality Modeling
Load the personality framework reference: `${SKILL_DIR}/references/personality_frameworks.md`
Map collected information to a multi-dimensional model:
**Layer 1 — Core Traits (Big Five / OCEAN)**
Score each dimension 0-100 based on observed evidence.
Flag dimensions with low confidence (insufficient data).
**Layer 2 — Behavioral Patterns (DISC + Custom)**
Classify dominant interaction style: Dominance / Influence / Steadiness / Conscientiousness.
Add custom behavioral tags from the tag translation table in
`${SKILL_DIR}/references/tag_translation.md`.
**Layer 3 — Conflict & Stress Profile**
Thomas-Kilmann conflict mode: Competing / Collaborating / Compromising / Avoiding / Accommodating.
Stress response pattern: fight / flight / freeze / fawn.
Trigger points: what specifically sets them off.
**Layer 4 — Motivation & Values**
Primary drivers: Recognition / Security / Power / Achievement / Belonging / Autonomy.
What they protect: reputation, territory, relationships, process.
**Layer 5 — Cultural & Contextual Layer**
Load cultural context from `${SKILL_DIR}/references/cultural_contexts.md`.
Load async communication calibration from `${SKILL_DIR}/references/async_communication.md`.
Load gender dynamics overlay from `${SKILL_DIR}/references/gender_dynamics.md` (when relevant).
Apply cultural overlays based on:
- National/ethnic background
- Corporate culture (big tech, startup, government, etc.)
- Generation / career stage
- Industry norms
### Step 4: Generate Persona Card
Output a structured persona card containing:
```
# [Name] — Persona Compass Card
## Quick Profile
- Role: [role & relationship to user]
- DISC Type: [type] | Conflict Style: [style]
- Primary Motivator: [motivator]
- Trust Level: [low/medium/high with user]
## Big Five Scores
- Openness: [score]/100 [confidence: high/medium/low]
- Conscientiousness: [score]/100
- Extraversion: [score]/100
- Agreeableness: [score]/100
- Neuroticism: [score]/100
## Behavioral Predictions
### Under Pressure
[specific predicted behaviors]
### When Receiving Bad News
[specific predicted behaviors]
### Trigger Points
[list of specific triggers with predicted reactions]
## Communication Playbook
### DO
[3-5 specific actionable tactics]
### DON'T
[3-5 specific things to avoid]
### Magic Phrases
[3-5 phrases calibrated to this person's psychology]
### Optimal Timing & Channel
[when and how to approach them]
## Confidence Assessment
- Overall model confidence: [percentage]
- Areas needing more data: [list]
```
### Step 5: Generate Persona Skill File (Generator Mode)
Do NOT just save data. Generate a fully self-contained SKILL.md for this person.
This file IS the memory — the CLI agent can load it directly with `/{slug}`.
No re-entry of information will ever be needed again.
**Follow the template exactly:** `${SKILL_DIR}/prompts/persona_skill_template.md`
**Determine Write Path based on your environment:**
- If you are running in **OpenClaw**: write to `~/.openclaw/workspace/skills/{slug}/SKILL.md`
- If you are running in **Claude Code**: write to `./.claude/skills/{slug}/SKILL.md` (if exists) OR `./personas/{slug}/SKILL.md`
- Default fallback: `./personas/{slug}/SKILL.md`
**Also write:** `observations.md` in the same directory as the SKILL.md — raw data log (gitignored, real name may appear here).
After writing, confirm to the user with the success message from the template.
> **Why this architecture?** Like colleague-skill, the file itself is the memory layer.
> One person = one loadable skill. Zero token overhead for context re-entry. OpenClaw and Claude Code natively support this.
---
## Memory Bridge Mode (Claude.ai Browser & Mobile)
**For users without file system access (Claude.ai web, mobile app):**
After completing a persona analysis, ALWAYS ask:
```
要把 [codename] 的画像存入 Claude Memory 吗?
存了之后你在任何对话里提到 "[codename]",我都能直接用这份画像,不用再重新描述。
[Yes / No]
```
If user says **Yes**, use the memory tool to save a compact persona card:
```
PERSONA_COMPASS:[codename]
role:[role] | rel:[relationship_to_user]
disc:[disc_type] | conflict:[conflict_style] | stress:[stress_pattern]
motivator:[primary_motivator] | trigger:[top_trigger_point]
do:[top_2_tactics] | dont:[top_2_avoids]
magic:"[single_best_phrase_calibrated_to_them]"
culture:[cultural_context_if_relevant]
confidence:[percent]% | updated:[YYYY-MM-DD]
```
**Example saved memory:**
```
PERSONA_COMPASS:sloth
role:PM | rel:direct-manager-controls-sprint
disc:D+C | conflict:avoider-delay | stress:more-control
motivator:credit+visibility | trigger:bypassed-or-surprised
do:data-first,give-credit-outlet | dont:oral-approvals,emotion
magic:"frame everything as affecting your KPI"
culture:big-tech-CN | confidence:72% | updated:2026-03-31
```
**In future conversations**, when user mentions "[codename]" or asks about that person:
1. Check memory for `PERSONA_COMPASS:[codename]`
2. If found: load the profile silently, do NOT ask user to re-describe
3. Respond immediately using the stored profile
4. Say: "Using your saved [codename] profile (confidence: X%). Update it with `/pc update [codename]`."
**Memory limits:** Keep each persona card under 150 tokens.
Store max 10-15 personas before older ones should be consolidated.
---
## Query Mode: Using an Existing Persona Skill
If the user loads a persona skill directly (`/{slug}` or references `personas/{slug}/SKILL.md`),
all context is already present in that file. Do NOT ask them to re-describe the person.
If queried from the main persona-compass skill:
1. Check `personas/` directory for existing slugs
2. If found, read `personas/{slug}/SKILL.md` directly — it is fully self-contained
3. Proceed with the query using that profile
**Scenario Simulation:**
- User describes a situation → Predict the person's reaction using the loaded profile
- Load scenario templates from `${SKILL_DIR}/references/scenario_templates.md`
- Output: predicted reaction + recommended strategy + specific scripts
**Strategy Request:**
- User needs to accomplish something involving this person
- Output: step-by-step approach with timing, channel, framing
- Include ready-to-use message drafts (Slack/email/talking points)
**Relationship Dynamics:**
- User asks about multi-person dynamics
- List available personas in `personas/` directory, cross-reference profiles
- Output: power map + alliance/conflict analysis + optimal positioning
**Message Drafting:**
- Generate 2-3 variants with different strategic approaches
- Each variant labeled with what it optimizes for (e.g., "Preserve relationship" vs "Assert boundary")
---
## Evolution Mode: Update Persona Skill
When user provides new information or corrections (`/pc update`):
1. Read `personas/{slug}/SKILL.md`
2. Classify the update:
- **New observation**: "He reacted differently than predicted" → Append to observations.md, refine model layers
- **Correction**: Update prediction model, note prediction accuracy
- **Context change**: "She got promoted" / "We had a falling out" → Adjust trust level, relationship dynamics, strategy
3. Rewrite `personas/{slug}/SKILL.md` with updated model
4. Update `Last updated` date and recalculate confidence scores
5. Confirm: "Updated {codename}'s profile. Here's what changed: [summary]"
---
## Built-in Scenario Templates
Load from `${SKILL_DIR}/references/scenario_templates.md`. Categories include:
**Workplace — Collaboration:**
deadline-slip, resource-request, cross-team-dependency, scope-change, delegation
**Workplace — Conflict:**
credit-dispute, blame-deflection, territory-invasion, public-disagreement, passive-aggression
**Workplace — Career:**
promotion-ask, salary-negotiation (with rejection recovery), skip-level-meeting, performance-review (with self-review calibration)
**Workplace — Boundaries:**
saying-no-to-boss, pushing-back-on-deadline, scope-creep-defense, protecting-work-life-balance
**Workplace — Communication:**
async-tone-calibration, meeting-vs-message-decision, email-length-optimization
**Personal — Family:**
financial-discussion, parenting-disagreement, boundary-setting, difficult-news
**Personal — Social:**
favor-request, confrontation, apology, boundary-enforcement
---
## Relationship Map Mode
Build and navigate multi-persona networks for organizational strategy.
Load the full system from `${SKILL_DIR}/references/relationship_map.md`.
### When to Activate
- User mentions 2+ people in the same situation
- User asks about "office politics", "org dynamics", "how to navigate"
- User describes a multi-party conflict or needs multi-stakeholder buy-in
- User says `/pc map`
### Core Capabilities
1. **Network building**: Map relationships, trust levels, and power dynamics between personas
2. **Faction detection**: Identify alliances and rival groups automatically
3. **Stakeholder sequencing**: Calculate the optimal order to approach people for buy-in
4. **Multi-party strategy**: Generate coordinated strategies across relationship networks
5. **Influence path finding**: Find the shortest path to influence a target person
### Data Storage
Network data stored in `personas/_network/map.json`.
Each persona file remains independent; the map is an overlay.
### Capacity
- No hard limit on number of personas
- 20-30 personas is the practical sweet spot for most users
- Single query can cross-reference up to 6-8 personas simultaneously
- Relationship map supports unlimited edges between personas
---
## Management Commands
| Command | Action |
|---------|--------|
| `/pc list` | List all saved personas (codenames only) |
| `/pc [codename]` | Load and query a persona |
| `/pc new` | Create a new persona (assigns codename) |
| `/pc update [codename]` | Add new observations |
| `/pc compare [cn1] [cn2]` | Compare two personas side-by-side |
| `/pc simulate [cn] [scenario]` | Run a full scenario simulation |
| `/pc draft [cn] "[context]"` | Generate ONLY a ready-to-copy message draft |
| `/pc prep [codename]` | 6-line pre-meeting cheat sheet (30 sec) |
| `/pc tone [codename]` | 1-line tone reminder (5 sec) |
| `/pc radar` | Weekly relationship scan + suggested actions |
| `/pc map` | Show relationship network |
| `/pc map add [cn1] [cn2] [rel]` | Add a relationship |
| `/pc map analyze` | Full network analysis with strategy |
| `/pc map factions` | Detect faction groupings |
---
## Ethical Guidelines (Built-in)
This skill operates under these non-negotiable principles:
1. **Optimize for mutual benefit.** Strategies should aim for win-win, not zero-sum.
2. **No manipulation.** Advice focuses on clear communication, not deception.
3. **Respect autonomy.** People are complex; models are approximations.
4. **Flag uncertainty.** When confidence is low, say so explicitly.
5. **Encourage direct communication.** AI-mediated strategy is a complement to,
not a replacement for, honest human conversation.
6. **Privacy by design.** Persona files stay local. No data leaves the user's machine.
No comments yet. Be the first to comment!