Qualified Self

If you're like me, you've done a lot of cool stuff in your life and career. Maybe too much stuff. Which things are most important to talk about? Heck, forget about how you talk about it to others -- which things did you, personally, forget about? Or maybe -- how do you understand yourself? You might be at a career crossroads.

There's mundane stuff you might want to do (what awesome stuff did I do and forget to put on my resume? What are my actual skills? What stories should I remember when I interview). But there's more important deeper stuff as well: should I be an IC or a manager next? What roles should I look for? what brings me joy? What am I good at compared to other people? What did I love doing, that I forgot about? Stuff like THAT.

This is a tool to answer those questions.

This is a tool to take ALL the evidence you have -- your old resumes, your performance reviews, your blog posts, your internal docs you wrote 3 jobs ago, whatever you have -- and then it turns that soup into:

1. Structured information (timeline, skills matrix, proof points)
2. Patterns (what you actually do well, your working style, what energizes you)
3. Suggestions (who you are, what's next, how to talk about it)
4. Fun artifacts (podcast script about your career, sketch comedy, interview prep)

Personal note: I built this for my own job search. It's been useful, yes. But more than useful: fun. Surprisingly moving. It helped me remember cool projects, great advice, and peer feedback I'd totally forgotten about. I hope you like it too.

— Sahar

How You Use This System

This system is designed for Claude Code. I bet it could be easily patched to use a different tool, but I haven’t done that work (yet?)

Claude Code is great. Ignore the “code” part in the name. It lets you run local AIs that:

• Read all your documents at once
• Execute complex multi-step workflows
• Generate and manage outputs automatically

You don't run scripts manually. You talk to Claude and it orchestrates everything for you.

Using a different AI coding assistant? Cursor, Aider, Windsurf, and others can work too, but may require adapting the instruction files.

What You Need Before Starting

Your Career Materials (required):

• Minimum: 10-15 documents with substantive content
  • Examples: Performance reviews, blog posts, project write-ups, self-reflections, internal memos you wrote, peer reviews, old resumes
  • The more evidence the better.
  • Primary documents are good.
• Formats: PDF, Word, markdown, or plain text all work
  • Markdown saves AI tokens (= lower costs), so convert PDFs if you're cost-conscious
  • Conversion tools are included in the repo!

Minor Technical Comfort (required):

• You can run terminal commands (like git clone)
• You can edit markdown files in a text editor
• That’s pretty much it.

Time Investment: 3-4 hours first time, 30-60 minutes for future runs. See detailed breakdown in "Getting Started" section below.

Who this is for: This is is best for senior folks (8+ years of experience) with scattered career evidence to analyze. Maybe especially if you’re trying to rethink things, or change roles. I bet it could be useful in other contexts or for other people, but that’s the target.

How It Works

I’m a data engineer. I think in pipelines. This is a pipeline that takes in a bunch of raw material up top, processes it according to different “scripts” (ai instructions) to build different files along the way, combines those files to make new files (again, using those scripts), and outputs a bunch of useful analysis and materials.

Raw Material          Compilation Instructions        Generated Output
(your evidence)   +   (analysis rules)           →    (insights & artifacts)
                                                              ↓
                                                          Archive
                                                     (every run saved)

The pieces:

1. Raw Material - Your career evidence (reviews, blog posts, work samples)

   • You maintain this (add new documents as your career evolves)
   • Never deleted, always growing

2. Compilation Instructions - Rules for analyzing evidence (tracked in git)

   • AI agents follow these instructions to generate outputs
   • You can customize these or use the defaults
   • A “compilation file” is the “code” that an LLM will use as instructions to process some upstream files and create a downstream file.

3. Generated Output - AI-produced insights and artifacts

   • Completely disposable and regenerable
   • If you don't like the output, tweak the instruction and regenerate

4. Archive - Snapshots of every pipeline run

   • Compare how your positioning evolves over time
   • Roll back if needed

The compilations run in waves:

• Primary - Directly analyze your raw documents (timeline, skills matrix)
• Secondary - Find patterns across primary outputs (what energizes you, working style)
• Frameworks - Synthesize across patterns, and come up with larger reports and strategy (who you are, how to talk about yourself)
• Artifacts - Generate specific materials (resume, recruiter email, interview prep)

Example: What You Actually Get

After your first pipeline run, you'll have 20+ markdown files analyzing different aspects of your career:

Understanding yourself:

• Internal Understanding - Deep synthesis of your professional identity, patterns, what energizes you
• Career Timeline - Chronological evidence showing role evolution
• Pattern Recognition - Recurring themes (e.g., "You don't just solve problems - you redesign systems so problems can't recur")
• Energy Audit - What work drains you vs energizes you (backed by evidence,)
• Many others.

Other:

• Gap Analysis - What evidence we’re missing and what you might add

Communicating to others:

• Communication Strategy - How to frame your story for different audiences (technical vs business, IC vs leadership)
• Strengths & Proof Points - What you're great at, with concrete examples
• Final Report - Comprehensive synthesis pulling everything together. Could be 50+ pages long.

Ready-to-use artifacts: These aren't generated by default but are easy to make at will

• Resumes - Optimized for different role types (VP Engineering, Principal Engineer, etc.)
• Recruiter Email Templates - How do you talk about yourself?
• Interview Prep Guides - Stories organized by competency
• Podcast Script - Conversational narration of your career (surprisingly moving)

Getting Started

1. Install Claude Code

Follow instructions at: https://github.com/anthropics/claude-code

The bridge from Claude Code to these instructions:

Claude Code is a CLI tool that lets you chat with Claude AI in your terminal. Open your terminal, move to this project folder, and then you’re ready. When you run commands like claude engineer or claude orchestrator, you're starting a conversation with Claude in a specific "mode" - with specialized instructions loaded.

Think of it like this:

• claude engineer → Claude reads engineer-context.agent.md and becomes your system engineer
• claude orchestrator → Claude reads orchestrator-context.agent.md and becomes your pipeline runner

These .agent.md files are instructions that tell Claude what its job is and how to do it. The system is built around these specialized modes.

Your workflow:

1. Start an agent in your terminal:

   cd <THIS_PROJECT_DIRECTORY>
   claude engineer    # For modifying the system itself
   # OR
   claude orchestrator    # For running the pipeline

2. Talk to it like a person:

   • Engineer mode: "Walk me through this system" or "Add a new compilation that analyzes my writing style"
   • Orchestrator mode: "Run the pipeline" or "Just regenerate the Primary compilations"

3. Pro tip: Use multiple terminal tabs with different agent modes. One tab for orchestration, another for engineering. Switch between them as your task changes.

2. Clone This Repo

git clone https://github.com/sayhar/qualified-self.git
cd qualified-self

3. Gather Your Documents

Collect your career materials - whatever you have:

• Performance reviews, peer feedback
• Blog posts, talks, articles you've written
• Project write-ups, internal memos, work samples
• Old resumes
• Self-reflections or journal entries about your work

Put them all in the repo root for now. The engineer will help organize them in the next step.

4. First Conversation with the Engineer

In your terminal:

claude engineer

Then say something like:

"Hey, I'm opening this for the first time. Can you:

1. Help me organize my documents into the right Raw Material subfolders?
2. Give me a tour of this system and how it works?
3. Help me configure base-context.agent.md with my info?
4. Adapt this system for me if needed? Feel free to ask me questions about what I'm looking for."

The engineer will:

• Create the necessary folder structure
• Move your documents into the right subfolders (Performance Reviews/, Self Reflections/, etc.)
• Walk you through the system
• Help you configure base-context.agent.md with your name, situation, and constraints
• Answer questions and customize compilations if needed

This conversation takes 15-30 minutes depending on how much customization you want.

5. Run Your First Pipeline

Once the engineer has helped you get set up, open a new terminal tab and run:

claude orchestrator

Then tell the orchestrator:

"Run the pipeline"

The orchestrator will:

1. Check dependencies between compilations
2. Archive any previous outputs (if they exist)
3. Execute compilations in the right order (Primary → Secondary → Frameworks → Artifacts)
4. Tell you when each wave completes

First run takes 30-60 minutes (AI processing time). Grab lunch. Go for a walk. This is deep analysis, not a quick scan.

Time Expectations

Setup (first time only): 3-4 hours total

• Gather documents, organize into folders: 1-2 hours
• Configure base-context.agent.md: 15-30 minutes
• First pipeline run: 30-60 minutes
• Review outputs, understand the system: 1-2 hours

Pipeline runtime (ongoing):

• Full pipeline: 30-60 minutes (perfect for a lunch break)
• Primary compilations only: 10-20 minutes
• Single compilation: 1-5 minutes

Why it takes time: Each compilation runs a separate AI agent that deeply analyzes your documents. Quality analysis isn't instant. But it's one-time work that replaces weeks of "stare at blank resume, rewrite cover letter" every time an opportunity appears.

Cost note: Pipeline runs use Claude API tokens. A typical full run costs $5-15 depending on how much material you have. Regenerating specific compilations costs pennies.

6. Review Your Outputs

Start in Pipeline/Generated Output/:

Read these first:

1. Internal Understanding - Who you are professionally (patterns, strengths, working style)
2. Communication Strategy - How to talk about yourself to different audiences
3. Pattern Recognition - Themes across your career you might have missed

Then explore:

• Career Timeline (your role evolution with evidence)
• Energy Audit (what work energizes vs drains you)
• Final Report (comprehensive synthesis - can be 60+ pages)

Generate the podcast script (seriously):

• Ask engineer mode: "Generate the podcast script artifact"
• It's a conversational narration of your career and what the analysis reveals
• Much more digestible than reading 60 pages

What happens next:

• Some insights will feel obvious ("Yeah, I knew that")
• Some will surprise you ("Oh wow, I forgot I did that")
• Some will reframe your understanding ("THAT'S why those roles felt wrong")

This is self-knowledge work. The outputs help you understand who you are professionally and how to talk about it authentically.

7. Iterate & Refine

As you evolve:

• Add new evidence (recent reviews, blog posts, projects)
• Regenerate the pipeline → your self-understanding stays current
• Compare archived runs to see how your positioning evolves

If a compilation misses something:

• Switch to claude engineer mode
• Ask: "The Energy Audit didn't catch X. Can we refine the instructions?"
• Regenerate that compilation

When you need materials for a specific role:

• "Generate a resume optimized for [role type]"
• "Create interview prep focused on [competency]"
• Your evidence base stays consistent, artifacts adapt to context

Key Concepts

Evidence over intuition - Compilations analyze actual documents, not assumptions about what you've done.

Separation of concerns - Strategic thinking stays separate from evidence analysis. The pipeline only reads from Raw Material (evidence about you), preventing circular reasoning.

Never lose work - Every pipeline run is archived before new outputs are generated.

Iterate on instructions, not outputs - If a compilation produces the wrong result, fix the instruction and regenerate.

Philosophy

The core insight: You are a special, interesting person with unique patterns in your work. Re-reading all your evidence will surface valuable ideas you've forgotten or never articulated clearly.

Most people approach career positioning as storytelling - "How do I sell myself?" This system flips it: What does the evidence actually say? Then tell that story.

What we avoid:

• No assumptions - The system doesn't presuppose what you're good at. It discovers patterns from your evidence.
• No contamination - Compilation instructions don't embed examples about you. They analyze your data without presupposing what they'll find.
• No wishful thinking - "I should do X" or "I might be good at Y" must emerge from evidence, not aspirations.

What we embrace:

• Room for review - Compilations include self-review steps because iteration improves quality
• Plain language internally - Use normal language when analyzing what's true. Save business-speak for external artifacts (resume, LinkedIn).
• Idempotency - Change your inputs, regenerate, outputs update automatically. Your materials stay consistent.

The result: Evidence-based self-knowledge instead of resume theater.

Directory Structure

Pipeline/
├── Raw Material/              # YOUR data (gitignored, permanent)
│   ├── Self Reflections/
│   ├── Performance Reviews/
│   ├── Online Presence/
│   └── Work Examples/
├── Reference Data/            # Market context (gitignored)
├── Compilation Instructions/  # The rules (tracked in git)
│   ├── Primary/              # Read from raw material
│   ├── Secondary/            # Read from primaries
│   ├── Frameworks/           # Higher-level synthesis
│   ├── Artifacts/            # Context-specific outputs
│   └── Config/               # Reference files
├── Generated Output/          # Results (gitignored, disposable)
└── System/                    # Runtime files (archiver, DAG builder)

Pipeline Development/          # Documentation about the system

Compilation Types

Primary - Directly analyze Raw Material

• Career Timeline, Skills Evidence Matrix, Filtered Proof Points

Secondary - Analyze Primary outputs

• Pattern Recognition, Gap Analysis, Energy Audit

Frameworks - Synthesize for communication

• Internal Understanding, Communication Strategy, Final Report

Artifacts - Context-specific outputs

• Resume, Recruiter Email, Interview Prep

Learn More

Deep dives:

• Pipeline Development/README - How Compilations Work.md - System architecture (waves, dependencies, the DAG)
• Pipeline Development/QUICKSTART - Running Pipeline.md - Manual execution guide

Want to customize? Work with claude engineer mode to modify compilation instructions or add new analyses.

What This System Is (And Isn't)

This repo is the evidence layer: Unidirectional data analysis (documents in, insights out).

What it does:

• Analyzes your career evidence
• Surfaces patterns and proof points
• Generates positioning frameworks
• Creates context-specific artifacts (resumes, emails, interview prep)

What it doesn't do:

• Decide if the insights are correct (you review and validate)
• Make strategic positioning choices (you decide which story to tell)
• Track job search activities (applications, follow-ups, networking)

Why the separation matters: It keeps the pipeline honest. The system generates insights based on evidence. You decide which insights are actually true and what to do about them.

Strategic decision-making (career direction, role targeting, job search operations) lives in a separate layer. This system gives you the raw material to make those decisions well.

Contributing

This project is in active development. Contributions welcome!

• Bug reports & feature requests: Open an issue on GitHub
• Pull requests: Bug fixes, new compilation templates, documentation improvements all accepted
• Questions: Use GitHub Issues for support

License

MIT