---

name: experience-as-skills description: "Converts personal professional experience into a structured agent skill — extracting frameworks, decision heuristics, mental models, and voice from sources like CVs, transcripts, Slack exports, notes, git history, books read, and conferences attended. Use when the user wants Claude to reason with their accumulated expertise, advise as them, or reference their career history." allowed-tools:

• Read
• Write
• Glob
• Grep
• shell_command argument-hint: <source-path-or-directory> [profile-name-slug]

---

Experience-as-Skills Converter

Turn lived professional experience into an actionable agent skill — extracting the frameworks, voice, and decision patterns that took years to develop.

Philosophy

Books contain an author's crystallized expertise. Your experience contains yours — but it's scattered across CVs, call transcripts, Slack threads, git commits, and notes. This skill extracts that tacit knowledge into a structured format Claude can reason with repeatedly.

Extract structure, not biography. A skill isn't a career summary. It's a toolkit of:

• Named personal frameworks (mental models you've actually used)
• Decision heuristics (rules you've developed through repeated situations)
• Domain depth (where you have genuine hard-won expertise)
• Voice calibration (how you communicate, reason, push back)
• Anti-patterns (what you've learned not to do, and why)

Preserve specificity. Your actual insight — "always validate the go-to-market motion before building the product" — is more useful than a generic platitude. Keep exact formulations.

Think before extracting. Per Karpathy: don't assume. If source material is ambiguous, ask. Surface tradeoffs between what to include. Push back if a simpler approach exists.

---

Modes of Operation

1. Full Conversion (Default)

Trigger: User provides a source path or directory without special instructions Action: Run all steps (Steps 0–9) Output: Complete experience skill with SKILL.md, domains/, voice.md, frameworks.md, history.md, lessons.md

2. Analyze Only

Trigger: User says "analyze", "just extract", or "show me what you find first" Action: Run Steps 0–3, produce a structured extraction report. Stop — do NOT write skill files. Output: Extraction report for user review and correction before committing

3. Generate from Prior Analysis

Trigger: User has reviewed an analysis report and wants to generate skill files from it Action: Skip Steps 0–3, use the provided analysis as input, run Steps 4–9 Output: Skill files from the provided analysis

---

Supported Source Types

| Source | Signal extracted | |--------|-----------------| | CV / résumé (PDF, DOCX, MD, TXT) | Career arc, roles, outcomes, domain expertise | | Transcripts / Granola / Gong (TXT, MD, JSON) | Decision patterns, communication style, recurring themes | | Slack export (JSON directory or TXT) | Working style, priorities, how you think under pressure | | Notes / writing (MD, TXT, RST) | Crystallized insights, frameworks, lessons learned | | Git log / commit history (text or git log output) | Technical depth, problem-solving patterns over time | | Books-read list (MD, TXT, CSV) | Absorbed knowledge domains, influences | | Conference notes / talk summaries (MD, TXT) | External frameworks adopted, network of ideas |

Multiple sources can be provided as a directory or as space-separated paths.

---

Output Targets

The skill generates files for every supported AI agent unless --target narrows the scope.

| Agent | Output path | Format | |-------|-------------|--------| | Claude Code | ~/.claude/skills/<slug>/SKILL.md | YAML frontmatter + markdown | | Amp | ~/.config/agents/skills/<slug>/SKILL.md | YAML frontmatter + markdown | | Cursor | .cursor/rules/<slug>-profile.mdc | MDC frontmatter (alwaysApply: false) | | GitHub Copilot | .github/copilot-instructions.md | Markdown, sentinel-guarded block |

When generating for all targets, run once and all four files are written. Re-running updates each file in place (Copilot uses sentinel comments to replace only the relevant block).

Skill Content Structure

profile/
├── SKILL.md / .mdc / copilot-instructions.md
│   ├── Core Frameworks & Mental Models   (~2,000 tokens)
│   ├── Voice & Reasoning Style           (~500 tokens)
│   ├── Domain Index                      (links to domain files)
│   └── Topic Index                       (alphabetical navigation)
├── domains/          Per-domain expertise — loaded on demand
├── voice.md          Communication style calibration (~1,000 tokens)
├── frameworks.md     Named personal mental models (~2,000 tokens)
├── history.md        Career arc and key decisions (~1,500 tokens)
└── lessons.md        Hard-won insights and anti-patterns (~1,500 tokens)

Domain files are loaded on-demand for Claude Code and Amp — they don't count against the skill budget until needed. For Cursor and Copilot, keep the injected file under ~4,000 tokens; reference domain files separately if needed.

---

Skill Locations

Prefer these locations in order:

1. Amp project-local: .agents/skills/
2. Amp global: ~/.config/agents/skills/
3. Amp legacy: ~/.config/amp/skills/
4. Claude Code: ~/.claude/skills/

Default output: ~/.config/agents/skills/ unless the user specifies otherwise.

---

Step 0 — Out-of-scope check

If no source path is provided, respond:

"experience-as-skills requires at least one source. Usage: /experience-as-skills <path-or-directory> [profile-slug]. Supported sources: CV/résumé, transcripts, Slack export, notes, git log, books-read list, conference notes."

---

Step 1 — Discover and validate sources

# If a directory is provided, list what's inside
ls -la "$SOURCE_PATH"

# Detect file types
file "$SOURCE_PATH"/* 2>/dev/null | head -40

# For git log input, check if it looks like git output
head -5 "$SOURCE_PATH"

For each source found, identify its type from the table above. If a file's type is ambiguous, read the first 500 characters before deciding — don't assume.

If none of the discovered files match a supported type, stop and list what was found. Ask the user to confirm or point to the right files.

Collect all valid sources into a list: SOURCES[] with (path, type) pairs.

---

Step 2 — Pre-flight summary

Before any extraction, tell the user what you found:

🔍 Sources discovered:

  CV / résumé         → <filename> (~N pages)
  Transcripts         → <N files> (~N total words)
  Notes               → <N files>
  Git log             → <N commits, date range>
  Books-read list     → <N entries>
  [...]

💡 Planned extraction:
  - Career arc and domain expertise from CV
  - Decision patterns and communication style from transcripts
  - Personal frameworks from notes
  - Technical depth signal from git history
  - [...]

⏱ Estimated time: ~N minutes
📁 Output: ~/.config/agents/skills/<slug>/

➡ Proceed with Full Conversion? (or type "analyze only" to preview first)

Wait for confirmation before proceeding. This is the Karpathy check — surface the plan, don't just run.

---

Step 3 — Extract and analyze each source

Process each source according to its type. For large files (>50K tokens), use grep/sed to probe rather than loading the whole file at once.

CV / Résumé

Read the full document. Extract:

• Career arc: roles in chronological order, companies, tenure
• Domain expertise: industries, technologies, functional areas
• Key outcomes: quantified results, notable projects, promotions
• Signals of depth: where the most detail and seniority appear

Transcripts (Granola / Gong / meeting notes)

For each transcript, grep for:

• Decision language: "I think we should", "my concern is", "I'd push back on"
• Framework language: recurring named approaches or heuristics
• Communication patterns: how they open, how they handle disagreement, how they close

grep -i -E "(I think|my concern|I'd push back|the key thing|in my experience|what I've found)" "$TRANSCRIPT"

Slack export

Sample across channels and time periods:

# For JSON export: pull message text
python3 -c "
import json, glob, sys
msgs = []
for f in glob.glob('$SLACK_DIR/**/*.json', recursive=True):
    for m in json.load(open(f)):
        if m.get('user') and m.get('text'):
            msgs.append(m['text'])
print('\n'.join(msgs[:500]))
"

Look for: working style signals, how they prioritize, how they handle ambiguity publicly.

Notes / Writing

Read each file. Extract named frameworks, lessons, principles. Flag anything already named (e.g. "The Rule of Three" or "my pre-mortem template").

Git log

# Summary stats
git -C "$REPO_PATH" log --oneline --since="5 years ago" | wc -l
git -C "$REPO_PATH" log --oneline --since="5 years ago" | head -50

# Commit message patterns (signals problem-solving style)
git -C "$REPO_PATH" log --pretty=format:"%s" --since="5 years ago" | sort | uniq -c | sort -rn | head -30

Look for: technical domains active in, problem types tackled, refactoring vs feature ratio.

Books-read list

Parse each entry. Group by domain. Note clusters — heavy reading in distributed systems, management, sales, etc. is a signal of serious depth.

Conference notes

Read each file. Extract: talks attended, speakers followed, frameworks adopted, ideas flagged as important.

---

Step 4 — Synthesize across sources (Full Conversion only)

After all sources are processed, synthesize into a unified picture. Look for:

1. Repeated themes — what topics appear across CV, notes, AND transcripts?
2. Named frameworks — anything the person has explicitly named and used more than once
3. Domain clusters — where is the genuine depth (vs. passing familiarity)?
4. Voice signatures — recurring phrases, communication habits, reasoning patterns
5. Inflection points — career moments where trajectory changed

If the analysis reveals inconsistency or ambiguity (e.g. the CV says "led product" but transcripts suggest more of an engineering role), surface it:

"I noticed X in your CV but Y in your transcripts. Which more accurately reflects your primary experience? This affects how I frame the skill."

---

Step 5 — Ask purpose and naming (Full Conversion only)

Ask the user:

"What's the primary way you'll use this skill? (Pick one or more)

1. Apply my frameworks while working — Claude uses your mental models on new problems
2. Advise as me — Claude reasons and communicates the way you would
3. Reference my history — Claude can answer 'what have I done with X before?'
4. All of the above"

Then ask for the profile slug if not already provided:

"What should this skill be called? Suggestions: <firstname>-profile, <lastname>-expertise, or <domain>-advisor"

---

Step 6 — Create skill directory

mkdir -p "$SKILLS_HOME/<profile-slug>/domains"

Check the directory doesn't already exist. If it does, ask before overwriting.

---

Step 7 — Generate domain files

For each significant domain identified in Step 3/4, create domains/<domain-slug>.md:

# <Domain Name>

## Depth Level
<Practitioner / Expert / Deep Expert> — based on years, outcomes, recurrence across sources

## How I Got Here
<2–3 sentences: the actual path — not a summary of the CV, but the narrative>

## Frameworks I Use in This Domain
- **<Framework Name>**: <what it is, when I apply it>
- **<Framework Name>**: <what it is, when I apply it>

## Hard-Won Principles
- <Principle>: <why, from experience — not generic advice>

## Anti-Patterns I've Seen
- **<What to avoid>**: <what happens when people do this>

## Go-To Approaches
<2–4 concrete methods or playbooks I reach for in this domain>

## Where My Depth Has Limits
<Honest about adjacencies I know less well — Karpathy principle: don't assume or overclaim>

Keep each domain file to 800–1,200 tokens. Dense, not verbose.

---

Step 8 — Generate supporting files

voice.md

Extract communication style from transcripts, Slack, and writing:

• Opening style (how do they start conversations/documents?)
• Reasoning pattern (deductive? anecdote-first? framework-first?)
• Disagreement style (how do they push back?)
• Closing/decision style (how do they land?)
• Recurring phrases and language patterns
• What they're notably NOT (avoids jargon? avoids hedging? blunt?)

Max ~1,000 tokens.

frameworks.md

Extract all personally-named or repeatedly-used mental models:

## <Framework Name>

**What it is**: <one sentence definition>
**When I use it**: <specific situation or trigger>
**How**: <the actual steps or criteria>
**Where it came from**: <experience, book, person — optional>
**Anti-pattern**: <what I used to do before / what this replaces>

Max ~2,000 tokens.

history.md

Timeline of career — structured for reference, not narrative:

## Career Arc

| Era | Role | Where | What I built/led/fixed | Key outcome |
|-----|------|--------|------------------------|-------------|
| <years> | <title> | <company> | <1-line> | <result> |

## Key Decisions
- **<Year>: <Decision>** — <why, what I chose, what happened>

## Inflection Points
- **<What changed>**: <before / after — the insight>

Max ~1,500 tokens.

lessons.md

Hard-won insights — things you know that most people learn slowly or never:

## <Lesson Title>

**The insight**: <1–2 sentences — exact formulation matters>
**Where it came from**: <brief context>
**What I do differently now**: <concrete behavior change>
**Common mistake**: <what others do instead>

Max ~1,500 tokens.

---

Step 9 — Generate the master SKILL.md

CRITICAL: Keep SKILL.md body under 4,000 tokens. Most important content first — compaction truncates from the end.

---
name: <profile-slug>
description: "Experience profile for <Name>. Embeds their frameworks, voice, and expertise in <top 3 domains>. Use when applying their mental models, reasoning as they would, or referencing their career experience."
allowed-tools:
  - Read
  - Grep
argument-hint: [domain, framework name, or question]
---

# <Name> — Experience Profile
**Generated**: <YYYY-MM-DD> | **Domains**: <N> | **Sources**: <list>

## How to Use This Skill

- **Without arguments** — load core frameworks and voice for reference
- **With a domain** — ask about `product-strategy` or `engineering-leadership`; I load that domain file
- **With a question** — ask "how would you approach X?"; I reason from the frameworks and voice
- **Browse** — ask "what domains do you have?" to see the full index

When a question goes beyond Core Frameworks below, I will read the relevant domain file before answering.

---

## Core Frameworks & Mental Models

<!-- ~2,000 tokens: the most important named frameworks with exact formulations.
Write as "Use X when Y", "Prefer X over Y because Z", "When facing X, ask Y".
This is a decision toolkit, not a biography. -->

<generate 2,000 tokens of the most critical personal frameworks and heuristics here>

---

## Voice & Reasoning Style

<!-- ~500 tokens: how this person communicates and reasons. Enough for Claude to calibrate tone. -->

<brief voice calibration — reasoning pattern, communication style, characteristic phrases>

---

## Domain Index

| Domain | Depth | File |
|--------|-------|------|
| [<domain>](domains/<domain>.md) | <Practitioner/Expert/Deep Expert> | |

## Topic Index

<!-- Key frameworks/concepts → where they live -->
- **<Framework>** → frameworks.md
- **<Domain topic>** → domains/<domain>.md
- **<Career event>** → history.md

## Supporting Files

- [voice.md](voice.md) — communication style and tone calibration
- [frameworks.md](frameworks.md) — all personal mental models
- [history.md](history.md) — career arc and key decisions
- [lessons.md](lessons.md) — hard-won insights and anti-patterns

---

## Scope & Limits

This skill reflects experience up to <date of sources>. For questions outside these domains, I'll say so rather than extrapolate. For current events or recent developments, check primary sources.

---

Step 10 — Cleanup and report

Remove any temp working files, then report:

✅ Experience skill created: $SKILLS_HOME/<profile-slug>/

👤 Profile: <Name>
📅 Sources span: <earliest> → <latest>
🧠 Domains: <N> (<list>)

Files generated:
  SKILL.md      — core frameworks + voice (~X tokens)
  domains/      — <N> domain files (~X tokens each, loaded on-demand)
  voice.md      — communication style (~X tokens)
  frameworks.md — personal mental models (~X tokens)
  history.md    — career arc + decisions (~X tokens)
  lessons.md    — hard-won insights (~X tokens)
────────────────────────────────────────────────────
Total skill size: ~X tokens (most loaded on-demand)

Usage:
  /<profile-slug>                          → load core frameworks
  /<profile-slug> product-strategy         → load that domain
  /<profile-slug> how would you approach X → reason from your frameworks
  /<profile-slug> what domains do you have → browse the index

---

Quality Rules

1. Extract structure, not biography — named frameworks and decision patterns, not career recaps
2. Preserve the person's exact formulations — their actual phrases and named models, not paraphrases
3. Think before extracting — if source material is ambiguous, ask. Don't assume and run. (Karpathy Rule 1)
4. Simplicity first — a tight 800-token domain file beats a 5,000-token dump. (Karpathy Rule 2)
5. Surgical per source — extract from each source what only that source can give. Don't repeat the same fact across voice.md, frameworks.md, and the domain file. (Karpathy Rule 3)
6. Define success criteria up front — before generating skill files, confirm the extraction report looks right. (Karpathy Rule 4)
7. Front-load SKILL.md — compaction keeps first 5,000 tokens; most important content comes first
8. Domain files are on-demand — they don't count against skill budget until loaded
9. Honest about limits — include "Where my depth has limits" in each domain. Don't overclaim.
10. Topic index is critical — it's how Claude navigates to the right file without loading everything