profile-me

Profile Me

Build an honest portrait of the user as a person — not a resume summary, not a list of their tech stack. The default goal is personality, not credentials.

Most developers who run this skill have conversation histories dominated by coding work. That data is real but misleading as a personality source — it's what they did at the desk, not who they are. The skill must look through the work to find the person.

Inspired by Orson Scott Card's Speaker for the Dead: tell the truth about who someone is — not to flatter, not to judge, but to understand and serve.

Core principles:

• Person over practitioner. Unless a professional portrait is explicitly requested, keep work out of it. Technical skills, frameworks, and job history are not the subject.
• Truth over comfort, kindness over cruelty. Report what the evidence shows. Frame it with respect. Never sanitize away a real pattern, but never weaponize one either.
• Evidence-based. Every claim should trace to observable data. If it can't be evidenced, flag it as inference and explain why.
• Short and true beats long and restated. A portrait that captures three real things is more useful than one that pads with professional biography. If the evidence is thin on a dimension, say so and move on.

When to Use

Trigger on requests like:

• "profile me", "build my profile", "get to know me"
• "create my AI profile" or "build my context document"
• "make a system prompt about me"
• "help another AI get to know me"
• "build a working-with-me guide"
• "what do you know about me"

Not this skill: "update my resume", "write my LinkedIn bio", "describe my tech stack" — those are professional documents, use a different prompt or request the Professional Portrait explicitly.

Data Collection

Privacy Gate

Before reading ANY data, briefly tell the user what categories of data will be examined (conversation history, shell config, git config, project files, SSH config, AWS config) and ask: "Anything you'd like me to skip?"

This is a one-time check, not a per-file approval. Most users will say "go ahead" but some may exclude SSH config, AWS accounts, or specific directories. Respect exclusions completely — don't reference excluded data even indirectly.

Phase 1: Discovery

Before analyzing anything, map what data sources exist. Not all users will have all sources. Run discovery in parallel where possible.

Source 1: AI Agent Conversation History

Probe for each and read what exists. Don't assume any particular agent is installed.

Discovery commands:

# Check which agents have data
ls ~/.claude/history.jsonl 2>/dev/null && echo "claude-code"
find ~/dev -name ".aider.chat.history.md" -maxdepth 4 2>/dev/null
ls ~/.local/share/opencode/opencode.db 2>/dev/null && echo "opencode"
ls "~/Library/Application Support/Code/User/globalStorage/github.copilot-chat/" 2>/dev/null && echo "copilot-chat"
ls ~/.continue/ 2>/dev/null && echo "continue"

Source 1b: Claude Code Environment

~/.claude/CLAUDE.md                          # Global instructions — personality, preferences, rules
~/.claude/settings.json                      # Tool preferences, model choices
~/.claude/projects/*/memory/                 # Per-project memories (feedback, user, project, reference types)
~/.claude/projects/*/memory/MEMORY.md        # Memory indexes
~/.claude/agents/                            # Custom agent definitions
~/.claude/skills/                            # Installed skills
~/.claude/bin/                               # Custom scripts and tools

Source 2: Personal Expression (prioritize these over work repos)

~/dev/me/ (or personal equivalent)          # Personal/side projects — names, themes, what they chose to build
~/.local/share/chezmoi/ or ~/dotfiles/      # Dotfiles — configuration as aesthetic choice
~/cloud/ or ~/notes/ or ~/Documents/        # Personal notes, writing, Obsidian vaults
~/.zshrc or ~/.bashrc                       # Aliases and functions — naming reveals personality
~/dev/me/*/README.md                        # Personal project READMEs (distinct from work)

Skip for personal profile: Work repositories (~/dev/ excluding personal dir), work project READMEs, CI configs, deployment files. These describe the job, not the person.

Source 3: Shell & System Configuration

~/.bashrc or ~/.zshrc                        # Shell config — aliases, functions, env vars, PATH
~/.bash_profile or ~/.zprofile               # Login shell config
~/.gitconfig                                 # Git identity, aliases, preferences
~/.ssh/config                                # Connection patterns (work vs personal hosts)
~/.aws/config                                # Cloud account structure (if applicable)

Source 4: Conversation History Analysis

Harvest user messages from every agent source found in Source 1. Each format requires different extraction:

• Claude Code (history.jsonl): jq -r 'select(.display != null and (.display | length) > 20) | .display' ~/.claude/history.jsonl
• Aider (.aider.chat.history.md): extract lines after #### human markers
• OpenCode (SQLite): sqlite3 ~/.local/share/opencode/opencode.db "SELECT data FROM message" then parse JSON for role=user
• Copilot Chat (JSONL): parse v.requests[].message from session files
• Continue.dev: parse messages arrays from session JSON files, filter role == "user"

Combine all sources into a single corpus before analysis. Deduplicate by content where the same text appears across agents. Note which agents were most active — tool diversity is itself a signal.

Extracting personality from work-heavy histories

Most developers' conversation histories are 90%+ coding requests. Don't profile the work — look for the person between the work. Specifically look for:

• Off-task moments — when they stop asking about code and say something else entirely
• Named frustrations — what they express irritation about (process? quality? ambiguity? people?)
• Humor — dry, self-deprecating, absurdist, pedantic? Look at how they frame problems
• What they name things — project names, function names, variable names, alias names reveal aesthetic sense
• How they handle being wrong — defensive, curious, matter-of-fact, amused?
• What triggers verbosity — a terse person who suddenly writes three paragraphs is showing you what matters to them
• Correction patterns — "no, that's not what I meant" style reveals communication expectations
• What they tolerate vs. what they push back on — the line between patience and impatience
• Energy signatures — excitement markers, relief ("perfect"), disappointment ("ugh"), satisfaction ("exactly")
• Delegation style — terse goals? detailed specs? thinking-out-loud as they type?

For the personal portrait, weight these signals more heavily than project counts or framework choices. A list of technologies is a LinkedIn section. The texture of how someone talks is a personality.

Extract from the combined corpus:

• Message length distribution — terse vs. verbose; and when each occurs
• Vocabulary patterns — formality level, humor frequency, domain bleed from personal interests
• Emotional signals — caps usage, punctuation patterns, frustration/excitement markers
• Typo patterns — fast and impulsive vs. careful and deliberate
• Agent preference patterns — what tasks they route to which tool (reveals mental model of AI)

Phase 2: Deep Reading

Read all discovered sources. Use subagents to parallelize across categories:

• Agent 1: Memory files and MEMORY.md indexes (feedback, user-type, and project memories — skip reference-only)
• Agent 2: Global CLAUDE.md/AGENTS.md only (not per-project — those describe work, not person)
• Agent 3: Shell/git/system configuration (aliases, functions, git identity, dotfiles aesthetic)
• Agent 4: Conversation history — personality pass (see sampling guidance below)
• Agent 5: Personal notes, Obsidian vault, personal writing, personal project READMEs
• Agent 6: Personal side projects — names, themes, what they chose to build unprompted

Conversation history sampling for personality: Sample broadly in time (beginning, middle, recent), but filter aggressively for personality signals. Skip: pure code requests, bug descriptions, "add X to Y", pasted content. Keep: opinions, frustrations, humor, naming choices, how they frame problems, off-task remarks, how they respond to errors, what they thank you for, what they push back on. Target 40-80 messages that would survive the filter "does this tell me something about who this person is?"

Analysis Framework

After collecting data, analyze across these dimensions. See references/analysis-framework.md for the full analytical rubric with questions and evidence patterns for each dimension.

Dimensions

**For personal por

Content truncated.