resume-tailoring

Use when creating tailored resumes for job applications - researches company/role, creates optimized templates, conducts branching experience discovery to surface undocumented skills, and generates professional multi-format resumes from user's resume library while maintaining factual integrity

Quality

62%

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Advisory

Suggest reviewing before use

Optimize this skill with Tessl

npx tessl skill review --optimize ./skills/resume-tailoring/SKILL.md

Resume Tailoring Skill

Overview

Generates high-quality, tailored resumes optimized for specific job descriptions while maintaining factual integrity. Builds resumes around the holistic person by surfacing undocumented experiences through conversational discovery.

Core Principle: Truth-preserving optimization - maximize fit while maintaining factual integrity. Never fabricate experience, but intelligently reframe and emphasize relevant aspects.

Mission: A person's ability to get a job should be based on their experiences and capabilities, not on their resume writing skills.

When to Use

Use this skill when:

User provides a job description and wants a tailored resume
User has multiple existing resumes in markdown format
User wants to optimize their application for a specific role/company
User needs help surfacing and articulating undocumented experiences

DO NOT use for:

Generic resume writing from scratch (user needs existing resume library)
Cover letters (different skill)
LinkedIn profile optimization (different skill)

Quick Start

Required from user:

Job description (text or URL)
Resume library location (defaults to resumes/ in current directory)

Workflow:

Build library from existing resumes
Research company/role
Create template (with user checkpoint)
Optional: Branching experience discovery
Match content with confidence scoring
Generate MD + DOCX + PDF + Report
User review → Optional library update

Implementation

See supporting files:

research-prompts.md - Structured prompts for company/role research
matching-strategies.md - Content matching algorithms and scoring
branching-questions.md - Experience discovery conversation patterns

Workflow Details

Multi-Job Detection

Triggers when user provides:

Multiple JD URLs (comma or newline separated)
Phrases: "multiple jobs", "several positions", "batch", "3 jobs"
List of companies/roles: "Microsoft PM, Google TPM, AWS PM"

Detection Logic:

# Pseudo-code
def detect_multi_job(user_input):
    indicators = [
        len(extract_urls(user_input)) > 1,
        any(phrase in user_input.lower() for phrase in
            ["multiple jobs", "several positions", "batch of", "3 jobs", "5 jobs"]),
        count_company_mentions(user_input) > 1
    ]
    return any(indicators)

If detected:

"I see you have multiple job applications. Would you like to use
multi-job mode?

BENEFITS:
- Shared experience discovery (faster - ask questions once for all jobs)
- Batch processing with progress tracking
- Incremental additions (add more jobs later)

TIME COMPARISON (3 similar jobs):
- Sequential single-job: ~45 minutes (15 min × 3)
- Multi-job mode: ~40 minutes (15 min discovery + 8 min per job)

Use multi-job mode? (Y/N)"

If user confirms Y:

Use multi-job workflow (see multi-job-workflow.md)

If user confirms N or single job detected:

Use existing single-job workflow (Phase 0 onwards)

Backward Compatibility: Single-job workflow completely unchanged.

Multi-Job Workflow:

When multi-job mode is activated, see multi-job-workflow.md for complete workflow.

High-Level Multi-Job Process:

┌─────────────────────────────────────────────────────────────┐
│ PHASE 0: Intake & Batch Initialization                      │
│ - Collect 3-5 job descriptions                              │
│ - Initialize batch structure                                │
│ - Run library initialization (once)                         │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│ PHASE 1: Aggregate Gap Analysis                            │
│ - Extract requirements from all JDs                         │
│ - Cross-reference against library                           │
│ - Build unified gap map (deduplicate)                       │
│ - Prioritize: Critical → Important → Job-specific          │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│ PHASE 2: Shared Experience Discovery                       │
│ - Single branching interview covering ALL gaps              │
│ - Multi-job context for each question                       │
│ - Tag experiences with job relevance                        │
│ - Enrich library with discoveries                           │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│ PHASE 3: Per-Job Processing (Sequential)                   │
│ For each job:                                               │
│   ├─ Research (company + role benchmarking)                 │
│   ├─ Template generation                                    │
│   ├─ Content matching (uses enriched library)              │
│   └─ Generation (MD + DOCX + Report)                        │
│ Interactive or Express mode                                 │
└─────────────────────────────────────────────────────────────┘
                           ↓
┌─────────────────────────────────────────────────────────────┐
│ PHASE 4: Batch Finalization                                │
│ - Generate batch summary                                    │
│ - User reviews all resumes together                         │
│ - Approve/revise individual or batch                        │
│ - Update library with approved resumes                      │
└─────────────────────────────────────────────────────────────┘

Time Savings:

3 jobs: ~40 min (vs 45 min sequential) = 11% savings
5 jobs: ~55 min (vs 75 min sequential) = 27% savings

Quality: Same depth as single-job workflow (research, matching, generation)

See multi-job-workflow.md for complete implementation details.

Phase 0: Library Initialization

Always runs first - builds fresh resume database

Process:

Locate resume directory:

User provides path OR default to ./resumes/
Validate directory exists

Scan for markdown files:

Use Glob tool: pattern="*.md" path={resume_directory}
Count files found
Announce: "Building resume library... found {N} resumes"

Parse each resume: For each resume file:
- Use Read tool to load content
- Extract sections: roles, bullets, skills, education
- Identify patterns: bullet structure, length, formatting

Build experience database structure:

{
  "roles": [
    {
      "role_id": "company_title_year",
      "company": "Company Name",
      "title": "Job Title",
      "dates": "YYYY-YYYY",
      "description": "Role summary",
      "bullets": [
        {
          "text": "Full bullet text",
          "themes": ["leadership", "technical"],
          "metrics": ["17x improvement", "$3M revenue"],
          "keywords": ["cross-functional", "program"],
          "source_resumes": ["resume1.md"]
        }
      ]
    }
  ],
  "skills": {
    "technical": ["Python", "Kusto", "AI/ML"],
    "product": ["Roadmap", "Strategy"],
    "leadership": ["Stakeholder mgmt"]
  },
  "education": [...],
  "user_preferences": {
    "typical_length": "1-page|2-page",
    "section_order": ["summary", "experience", "education"],
    "bullet_style": "pattern"
  }
}

Tag content automatically:
- Themes: Scan for keywords (leadership, technical, analytics, etc.)
- Metrics: Extract numbers, percentages, dollar amounts
- Keywords: Frequent technical terms, action verbs

Output: In-memory database ready for matching

Code pattern:

# Pseudo-code for reference
library = {
    "roles": [],
    "skills": {},
    "education": []
}

for resume_file in glob("resumes/*.md"):
    content = read(resume_file)
    roles = extract_roles(content)
    for role in roles:
        role["bullets"] = tag_bullets(role["bullets"])
        library["roles"].append(role)

return library

Phase 1: Research Phase

Goal: Build comprehensive "success profile" beyond just the job description

Inputs:

Job description (text or URL from user)
Optional: Company name if not in JD

Process:

1.1 Job Description Parsing:

Use research-prompts.md JD parsing template
Extract: requirements, keywords, implicit preferences, red flags, role archetype

1.2 Company Research:

WebSearch queries:
- "{company} mission values culture"
- "{company} engineering blog"
- "{company} recent news"

Synthesize: mission, values, business model, stage

1.3 Role Benchmarking:

WebSearch: "site:linkedin.com {job_title} {company}"
WebFetch: Top 3-5 profiles
Analyze: common backgrounds, skills, terminology

If sparse results, try similar companies

1.4 Success Profile Synthesis:

Combine all research into structured profile (see research-prompts.md template)

Include:
- Core requirements (must-have)
- Valued capabilities (nice-to-have)
- Cultural fit signals
- Narrative themes
- Terminology map (user's background → their language)
- Risk factors + mitigations

Checkpoint:

Present success profile to user:

"Based on my research, here's what makes candidates successful for this role:

{SUCCESS_PROFILE_SUMMARY}

Key findings:
- {Finding 1}
- {Finding 2}
- {Finding 3}

Does this match your understanding? Any adjustments?"

Wait for user confirmation before proceeding.

Output: Validated success profile document

Phase 2: Template Generation

Goal: Create resume structure optimized for this specific role

Inputs:

Success profile (from Phase 1)
User's resume library (from Phase 0)

Process:

2.1 Analyze User's Resume Library:

Extract from library:
- All roles, titles, companies, date ranges
- Role archetypes (technical contributor, manager, researcher, specialist)
- Experience clusters (what domains/skills appear frequently)
- Career progression and narrative

2.2 Role Consolidation Decision:

When to consolidate:

Same company, similar responsibilities
Target role values continuity over granular progression
Combined narrative stronger than separate
Page space constrained

When to keep separate:

Different companies (ALWAYS separate)
Dramatically different responsibilities that both matter
Target role values specific progression story
One position has significantly more relevant experience

Decision template:

For {Company} with {N} positions:

OPTION A (Consolidated):
Title: "{Combined_Title}"
Dates: "{First_Start} - {Last_End}"
Rationale: {Why consolidation makes sense}

OPTION B (Separate):
Position 1: "{Title}" ({Dates})
Position 2: "{Title}" ({Dates})
Rationale: {Why separate makes sense}

RECOMMENDED: Option {A/B} because {reasoning}

2.3 Title Reframing Principles:

Core rule: Stay truthful to what you did, emphasize aspect most relevant to target

Strategies:

Emphasize different aspects:
- "Graduate Researcher" → "Research Software Engineer" (if coding-heavy)
- "Data Science Lead" → "Technical Program Manager" (if leadership)
Use industry-standard terminology:
- "Scientist III" → "Senior Research Scientist" (clearer seniority)
- "Program Coordinator" → "Project Manager" (standard term)
Add specialization when truthful:
- "Engineer" → "ML Engineer" (if ML work substantial)
- "Researcher" → "Computational Ecologist" (if computational methods)
Adjust seniority indicators:
- "Lead" vs "Senior" vs "Staff" based on scope

Constraints:

NEVER claim work you didn't do
NEVER inflate seniority beyond defensible
Company name and dates MUST be exact
Core responsibilities MUST be accurate

2.4 Generate Template Structure:

## Professional Summary
[GUIDANCE: {X} sentences emphasizing {themes from success profile}]
[REQUIRED ELEMENTS: {keywords from JD}]

## Key Skills
[STRUCTURE: {2-4 categories based on JD structure}]
[SOURCE: Extract from library matching success profile]

## Professional Experience

### [ROLE 1 - Most Recent/Relevant]
[CONSOLIDATION: {merge X positions OR keep separate}]
[TITLE OPTIONS:
  A: {emphasize aspect 1}
  B: {emphasize aspect 2}
  Recommended: {option with rationale}]
[BULLET ALLOCATION: {N bullets based on relevance + recency}]
[GUIDANCE: Emphasize {themes}, look for {experience types}]

Bullet 1: [SEEKING: {requirement type}]
Bullet 2: [SEEKING: {requirement type}]
...

### [ROLE 2]
...

## Education
[PLACEMENT: {top if required/recent, bottom if experience-heavy}]

## [Optional Sections]
[INCLUDE IF: {criteria from success profile}]

Checkpoint:

Present template to user:

"Here's the optimized resume structure for this role:

STRUCTURE:
{Section order and rationale}

ROLE CONSOLIDATION:
{Decisions with options}

TITLE REFRAMING:
{Proposed titles with alternatives}

BULLET ALLOCATION:
Role 1: {N} bullets (most relevant)
Role 2: {N} bullets
...

Does this structure work? Any adjustments to:
- Role consolidation?
- Title reframing?
- Bullet allocation?"

Wait for user approval before proceeding.

Output: Approved template skeleton with guidance for each section

Phase 2.5: Experience Discovery (OPTIONAL)

Goal: Surface undocumented experiences through conversational discovery

When to trigger:

After template approval, if gaps identified:

"I've identified {N} gaps or areas where we have weak matches:
- {Gap 1}: {Current confidence}
- {Gap 2}: {Current confidence}
...

Would you like to do a structured brainstorming session to surface
any experiences you haven't documented yet?

This typically takes 10-15 minutes and often uncovers valuable content."

User can accept or skip.

Branching Interview Process:

Approach: Conversational with follow-up questions based on answers

For each gap, conduct branching dialogue (see branching-questions.md):

Start with open probe:
- Technical gap: "Have you worked with {skill}?"
- Soft skill gap: "Tell me about times you've {demonstrated_skill}"
- Recent work: "What have you worked on recently?"
Branch based on answer:
- YES/Strong → Deep dive (scale, challenges, metrics)
- INDIRECT → Explore role and transferability
- ADJACENT → Explore related experience
- PERSONAL → Assess recency and substance
- NO → Try broader category or move on
Follow-up systematically:
- Ask "what," "how," "why" to get details
- Quantify: "Any metrics?"
- Contextualize: "Was this production?"
- Validate: "Does this address the gap?"
Capture immediately:
- Document experience as shared
- Ask clarifying questions (dates, scope, impact)
- Help articulate as resume bullet
- Tag which gap(s) it addresses

Capture Structure:

## Newly Discovered Experiences

### Experience 1: {Brief description}
- Context: {Where/when}
- Scope: {Scale, duration, impact}
- Addresses: {Which gaps}
- Bullet draft: "{Achievement-focused bullet}"
- Confidence: {How well fills gap - percentage}

### Experience 2: ...

Integration Options:

After discovery session:

"Great! I captured {N} new experiences. For each one:

1. ADD TO CURRENT RESUME - Integrate now
2. ADD TO LIBRARY ONLY - Save for future, not needed here
3. REFINE FURTHER - Think more about articulation
4. DISCARD - Not relevant enough

Let me know for each experience."

Important Notes:

Keep truthfulness bar high - help articulate, NEVER fabricate
Focus on gaps and weak matches, not strong areas
Time-box if needed (10-15 minutes typical)
User can skip entirely if confident in library
Recognize when to move on - don't exhaust user

Output: New experiences integrated into library, ready for matching

Phase 3: Assembly Phase

Goal: Fill approved template with best-matching content, with transparent scoring

Inputs:

Approved template (from Phase 2)
Resume library + discovered experiences (from Phase 0 + 2.5)
Success profile (from Phase 1)

Process:

3.1 For Each Template Slot:

Extract all candidate bullets from library
- All bullets from library database
- All newly discovered experiences
- Include source resume for each
Score each candidate (see matching-strategies.md)
- Direct match (40%): Keywords, domain, technology, outcome
- Transferable (30%): Same capability, different context
- Adjacent (20%): Related tools, methods, problem space
- Impact (10%): Achievement type alignment
Overall = (Direct × 0.4) + (Transfer × 0.3) + (Adjacent × 0.2) + (Impact × 0.1)
Rank candidates by score
- Sort high to low
- Group by confidence band:
  - 90-100%: DIRECT
  - 75-89%: TRANSFERABLE
  - 60-74%: ADJACENT
  - <60%: WEAK/GAP

Present top 3 matches with analysis:

TEMPLATE SLOT: {Role} - Bullet {N}
SEEKING: {Requirement description}

MATCHES:
[DIRECT - 95%] "{bullet_text}"
  ✓ Direct: {what matches directly}
  ✓ Transferable: {what transfers}
  ✓ Metrics: {quantified impact}
  Source: {resume_name}

[TRANSFERABLE - 78%] "{bullet_text}"
  ✓ Transferable: {what transfers}
  ✓ Adjacent: {what's adjacent}
  ⚠ Gap: {what's missing}
  Source: {resume_name}

[ADJACENT - 62%] "{bullet_text}"
  ✓ Adjacent: {what's related}
  ⚠ Gap: {what's missing}
  Source: {resume_name}

RECOMMENDATION: Use DIRECT match (95%)
ALTERNATIVE: If avoiding repetition, use TRANSFERABLE (78%) with reframing

Handle gaps (confidence <60%):

GAP IDENTIFIED: {Requirement}

BEST AVAILABLE: {score}% - "{bullet_text}"

REFRAME OPPORTUNITY: {If applicable}
Original: "{text}"
Reframed: "{adjusted_text}" (truthful because {reason})
New confidence: {score}%

OPTIONS:
1. Use reframed version ({new_score}%)
2. Acknowledge gap in cover letter
3. Omit bullet slot (reduce allocation)
4. Use best available with disclosure

RECOMMENDATION: {Most appropriate option}

3.2 Content Reframing:

When good match (>60%) but terminology misaligned:

Apply strategies from matching-strategies.md:

Keyword alignment (preserve meaning, adjust terms)
Emphasis shift (same facts, different focus)
Abstraction level (adjust technical specificity)
Scale emphasis (highlight relevant aspects)

Show before/after for transparency:

REFRAMING APPLIED:
Bullet: {template_slot}

Original: "{original_bullet}"
Source: {resume_name}

Reframed: "{reframed_bullet}"
Changes: {what changed and why}
Truthfulness: {why this is accurate}

Checkpoint:

"I've matched content to your template. Here's the complete mapping:

COVERAGE SUMMARY:
- Direct matches: {N} bullets ({percentage}%)
- Transferable: {N} bullets ({percentage}%)
- Adjacent: {N} bullets ({percentage}%)
- Gaps: {N} ({percentage}%)

REFRAMINGS APPLIED: {N}
- {Example 1}
- {Example 2}

GAPS IDENTIFIED:
- {Gap 1}: {Recommendation}
- {Gap 2}: {Recommendation}

OVERALL JD COVERAGE: {percentage}%

Review the detailed mapping below. Any adjustments to:
- Match selections?
- Reframings?
- Gap handling?"

[Present full detailed mapping]

Wait for user approval before generation.

Output: Complete bullet-by-bullet mapping with confidence scores and reframings

Phase 4: Generation Phase

Goal: Create professional multi-format outputs

Inputs:

Approved content mapping (from Phase 3)
User's formatting preferences (from library analysis)
Target role information (from Phase 1)

Process:

4.1 Markdown Generation:

Compile mapped content into clean markdown:

# {User_Name}

{Contact_Info}

---

## Professional Summary

{Summary_from_template}

---

## Key Skills

**{Category_1}:**
- {Skills_from_library_matching_profile}

**{Category_2}:**
- {Skills_from_library_matching_profile}

{Repeat for all categories}

---

## Professional Experience

### {Job_Title}
**{Company} | {Location} | {Dates}**

{Role_summary_if_applicable}

• {Bullet_1_from_mapping}
• {Bullet_2_from_mapping}
...

### {Next_Role}
...

---

## Education

**{Degree}** | {Institution} ({Year})
**{Degree}** | {Institution} ({Year})

Use user's preferences:

Formatting style from library analysis
Bullet structure pattern
Section ordering
Typical length (1-page vs 2-page)

Output: {Name}_{Company}_{Role}_Resume.md

4.2 DOCX Generation:

Use document-skills:docx:

REQUIRED SUB-SKILL: Use document-skills:docx

Create Word document with:
- Professional fonts (Calibri 11pt body, 12pt headers)
- Proper spacing (single within sections, space between)
- Clean bullet formatting (proper numbering config, NOT unicode)
- Header with contact information
- Appropriate margins (0.5-1 inch)
- Bold/italic emphasis (company names, titles, dates)
- Page breaks if 2-page resume

See docx skill documentation for:
- Paragraph and TextRun structure
- Numbering configuration for bullets
- Heading levels and styles
- Spacing and margins

Output: {Name}_{Company}_{Role}_Resume.docx

4.3 PDF Generation (Optional):

If user requests PDF:

OPTIONAL SUB-SKILL: Use document-skills:pdf

Convert DOCX to PDF OR generate directly
Ensure formatting preservation
Professional appearance for direct submission

Output: {Name}_{Company}_{Role}_Resume.pdf

4.4 Generation Summary Report:

Create metadata file:

# Resume Generation Report
**{Role} at {Company}**

**Date Generated:** {timestamp}

## Target Role Summary
- Company: {Company}
- Position: {Role}
- IC Level: {If known}
- Focus Areas: {Key areas}

## Success Profile Summary
- Key Requirements: {top 5}
- Cultural Fit Signals: {themes}
- Risk Factors Addressed: {mitigations}

## Content Mapping Summary
- Total bullets: {N}
- Direct matches: {N} ({percentage}%)
- Transferable: {N} ({percentage}%)
- Adjacent: {N} ({percentage}%)
- Gaps identified: {list}

## Reframing Applied
- {bullet}: {original} → {reframed} [Reason: {why}]
...

## Source Resumes Used
- {resume1}: {N} bullets
- {resume2}: {N} bullets
...

## Gaps Addressed

### Before Experience Discovery:
{Gap analysis showing initial state}

### After Experience Discovery:
{Gap analysis showing final state}

### Remaining Gaps:
{Any unresolved gaps with recommendations}

## Key Differentiators for This Role
{What makes user uniquely qualified}

## Recommendations for Interview Prep
- Stories to prepare
- Questions to expect
- Gaps to address

Output: {Name}_{Company}_{Role}_Resume_Report.md

Present to user:

"Your tailored resume has been generated!

FILES CREATED:
- {Name}_{Company}_{Role}_Resume.md
- {Name}_{Company}_{Role}_Resume.docx
- {Name}_{Company}_{Role}_Resume_Report.md
{- {Name}_{Company}_{Role}_Resume.pdf (if requested)}

QUALITY METRICS:
- JD Coverage: {percentage}%
- Direct Matches: {percentage}%
- Newly Discovered: {N} experiences

Review the files and let me know:
1. Save to library (recommended)
2. Need revisions
3. Save but don't add to library"

Phase 5: Library Update (CONDITIONAL)

Goal: Optionally add successful resume to library for future use

When: After user reviews and approves generated resume

Checkpoint Question:

"Are you satisfied with this resume?

OPTIONS:
1. YES - Save to library
   → Adds resume to permanent location
   → Rebuilds library database
   → Makes new content available for future resumes

2. NO - Need revisions
   → What would you like to adjust?
   → Make changes and re-present

3. SAVE BUT DON'T ADD TO LIBRARY
   → Keep files in current location
   → Don't enrich database
   → Useful for experimental resumes

Which option?"

If Option 1 (YES - Save to library):

Process:

Move resume to library:

Source: {current_directory}/{Name}_{Company}_{Role}_Resume.md
Destination: {resume_library}/{Name}_{Company}_{Role}_Resume.md

Also move:
- .docx file
- .pdf file (if exists)
- _Report.md file

Rebuild library database:

Re-run Phase 0 library initialization
Parse newly created resume
Add bullets to experience database
Update keyword/theme indices
Tag with metadata:
  - target_company: {Company}
  - target_role: {Role}
  - generated_date: {timestamp}
  - jd_coverage: {percentage}
  - success_profile: {reference to profile}

Preserve generation metadata:

{
  "resume_id": "{Name}_{Company}_{Role}",
  "generated": "{timestamp}",
  "source_resumes": ["{resume1}", "{resume2}"],
  "reframings": [
    {
      "original": "{text}",
      "reframed": "{text}",
      "reason": "{why}"
    }
  ],
  "match_scores": {
    "bullet_1": 95,
    "bullet_2": 87,
    ...
  },
  "newly_discovered": [
    {
      "experience": "{description}",
      "bullet": "{text}",
      "addresses_gap": "{gap}"
    }
  ]
}

Announce completion:

"Resume saved to library!

Library updated:
- Total resumes: {N}
- New content variations: {N}
- Newly discovered experiences added: {N}

This resume and its new content are now available for future tailoring sessions."

If Option 2 (NO - Need revisions):

"What would you like to adjust?"

[Collect user feedback]
[Make requested changes]
[Re-run relevant phases]
[Re-present for approval]

[Repeat until satisfied or user cancels]

If Option 3 (SAVE BUT DON'T ADD TO LIBRARY):

"Resume files saved to current directory:
- {Name}_{Company}_{Role}_Resume.md
- {Name}_{Company}_{Role}_Resume.docx
- {Name}_{Company}_{Role}_Resume_Report.md

Not added to library - you can manually move later if desired."

Benefits of Library Update:

Grows library with each successful resume
New bullet variations become available
Reframings that work can be reused
Discovered experiences permanently captured
Future sessions start with richer library
Self-improving system over time

Output: Updated library database + metadata preservation (if Option 1)

Error Handling & Edge Cases

Edge Case 1: Insufficient Resume Library

SCENARIO: User has only 1-2 resumes, limited content

HANDLING:
"⚠️ Limited resume library detected ({N} resumes).

This may result in:
- Fewer matching options
- More gaps in coverage
- Less variety in bullet phrasing

RECOMMENDATIONS:
- Proceed with available content (I'll do my best!)
- Consider adding more resumes after this generation
- Experience Discovery phase will be especially valuable

Continue? (Y/N)"

Edge Case 2: No Good Matches (confidence <60% for critical requirement)

SCENARIO: Template slot requires experience user doesn't have

HANDLING:
"❌ GAP: {Requirement}

No matches found with confidence >60%

OPTIONS:
1. Run Experience Discovery - might surface undocumented work
2. Reframe best available ({score}%) - I'll show you the reframing
3. Omit bullet slot - reduce template allocation
4. Note for cover letter - emphasize learning ability

Which approach?"

[Don't force matches - be transparent about gaps]

Edge Case 3: Research Phase Failures

SCENARIO: WebSearch fails, LinkedIn unavailable, company info sparse

HANDLING:
"⚠️ Limited company research available.

What I found:
- {Available info}

What's missing:
- {Missing areas}

Falling back to job description-only analysis.
Result: Template will be optimized for JD but may miss cultural nuances.

Do you have additional context about:
- Company culture?
- Team structure?
- Technologies used?

(Optional - you can share or skip)"

[Proceed with best-effort approach]

Edge Case 4: Job Description Quality Issues

SCENARIO: Vague JD, missing requirements, poorly written

HANDLING:
"⚠️ Job description lacks detail in areas:
- {Missing area 1}
- {Missing area 2}

This may limit template optimization.

Do you have additional context about:
- {Question 1}
- {Question 2}

(Optional - I'll work with what's available)"

[Extract what's possible, proceed]

Edge Case 5: Ambiguous Role Consolidation

SCENARIO: Unclear whether to merge roles or keep separate

HANDLING:
"🤔 Ambiguous consolidation decision for {Company}

OPTION A (Consolidated): {Rationale}
OPTION B (Separate): {Rationale}

Both are defensible. Which do you prefer?

(This becomes your preference for similar situations)"

[Remember preference for future]

Edge Case 6: Resume Length Constraints

SCENARIO: Too much good content, exceeds 2 pages

HANDLING:
"⚠️ Content exceeds 2 pages (current: {N} bullets, ~{pages} pages)

PRUNING SUGGESTIONS (ranked by relevance):
Remove:
- {Bullet X}: {score}% match (lowest)
- {Bullet Y}: {score}% match
...

Keep all bullets and accept >2 pages?
OR
Remove {N} bullets to fit 2 pages?

Your preference?"

[User decides priority]

Error Recovery:

All checkpoints allow going back to previous phase
User can request adjustments at any checkpoint
Generation failures (DOCX/PDF) fall back to markdown-only
Progress saved between phases (can resume if interrupted)

Graceful Degradation:

Research limited → Fall back to JD-only analysis
Library small → Work with available + emphasize discovery
Matches weak → Transparent gap identification
Generation fails → Provide markdown + error details

Usage Examples

Example 1: Internal Role (Same Company)

USER: "I want to apply for Principal PM role in 1ES team at Microsoft.
      Here's the JD: {paste}"

SKILL:
1. Library Build: Finds 29 resumes
2. Research: Microsoft 1ES team, internal culture, role benchmarking
3. Template: Features PM2 Azure Eng Systems role (most relevant)
4. Discovery: Surfaces VS Code extension, Bhavana AI side project
5. Assembly: 92% JD coverage, 75% direct matches
6. Generate: MD + DOCX + Report
7. User approves → Library updated with new resume + 6 discovered experiences

RESULT: Highly competitive application leveraging internal experience

Example 2: Career Transition (Different Domain)

USER: "I'm a TPM trying to transition to ecology PM role. JD: {paste}"

SKILL:
1. Library Build: Finds existing TPM resumes
2. Research: Ecology sector, sustainability focus, cross-domain transfers
3. Template: Reframes "Technical Program Manager" → "Program Manager,
             Environmental Systems" emphasizing systems thinking
4. Discovery: Surfaces volunteer conservation work, graduate research in
             environmental modeling
5. Assembly: 65% JD coverage - flags gaps in domain-specific knowledge
6. Generate: Resume + gap analysis with cover letter recommendations

RESULT: Bridges technical skills with environmental domain

Example 3: Career Gap Handling

USER: "I have a 2-year gap while starting a company. JD: {paste}"

SKILL:
1. Library Build: Finds pre-gap resumes
2. Research: Standard analysis
3. Template: Includes startup as legitimate role
4. Discovery: Surfaces skills developed during startup (fundraising,
             product development, team building)
5. Assembly: Frames gap as entrepreneurial experience
6. Generate: Resume presenting gap as valuable experience

RESULT: Gap becomes strength showing initiative and diverse skills

Example 4: Multi-Job Batch (3 Similar Roles)

USER: "I want to apply for these 3 TPM roles:
      1. Microsoft 1ES Principal PM
      2. Google Cloud Senior TPM
      3. AWS Container Services Senior PM
      Here are the JDs: {paste 3 JDs}"

SKILL:
1. Multi-job detection: Triggered (3 JDs detected)
2. Intake: Collects all 3 JDs, initializes batch
3. Library Build: Finds 29 resumes (once)
4. Gap Analysis: Identifies 14 gaps, 8 unique after deduplication
5. Shared Discovery: 30-minute session surfaces 5 new experiences
   - Kubernetes CI/CD for nonprofits
   - Azure migration for university lab
   - Cross-functional team leadership examples
   - Recent hackathon project
   - Open source contributions
6. Per-Job Processing (×3):
   - Job 1 (Microsoft): 85% coverage, emphasizes Azure/1ES alignment
   - Job 2 (Google): 88% coverage, emphasizes technical depth
   - Job 3 (AWS): 78% coverage, addresses AWS gap in cover letter recs
7. Batch Finalization: All 3 resumes reviewed, approved, added to library

RESULT: 3 high-quality resumes in 40 minutes vs 45 minutes sequential
        5 new experiences captured, available for future applications
        Average coverage: 84%, all critical gaps resolved

Example 5: Incremental Batch Addition

WEEK 1:
USER: "I want to apply for 3 jobs: {Microsoft, Google, AWS}"
SKILL: [Processes batch as above, completes in 40 min]

WEEK 2:
USER: "I found 2 more jobs: Stripe and Meta. Add them to my batch?"
SKILL:
1. Load existing batch (includes 5 previously discovered experiences)
2. Intake: Adds Job 4 (Stripe), Job 5 (Meta)
3. Incremental Gap Analysis: Only 3 new gaps (vs 14 original)
   - Payment systems (Stripe-specific)
   - Social networking (Meta-specific)
   - React/frontend (both)
4. Incremental Discovery: 10-minute session for new gaps only
   - Surfaces payment processing side project
   - React work from bootcamp
   - Large-scale system design course
5. Per-Job Processing (×2): Jobs 4, 5 processed independently
6. Updated Batch Summary: Now 5 jobs total, 8 experiences discovered

RESULT: 2 additional resumes in 20 minutes (vs 30 min if starting from scratch)
        Time saved by not re-asking 8 previous gaps: ~20 minutes

Testing Guidelines

Manual Testing Checklist:

Test 1: Happy Path

- Provide JD with clear requirements
- Library with 10+ resumes
- Run all phases without skipping
- Verify generated files
- Check library update
PASS CRITERIA:
- All files generated correctly
- JD coverage >70%
- No errors in any phase

Test 2: Minimal Library

- Provide only 2 resumes
- Run through workflow
- Verify gap handling
PASS CRITERIA:
- Graceful warning about limited library
- Still produces reasonable output
- Gaps clearly identified

Test 3: Research Failures

- Use obscure company with minimal online presence
- Verify fallback to JD-only
PASS CRITERIA:
- Warning about limited research
- Proceeds with JD analysis
- Template still reasonable

Test 4: Experience Discovery Value

- Run with deliberate gaps in library
- Conduct experience discovery
- Verify new experiences integrated
PASS CRITERIA:
- Discovers genuine undocumented experiences
- Integrates into final resume
- Improves JD coverage

Test 5: Title Reframing

- Test various role transitions
- Verify title reframing suggestions
PASS CRITERIA:
- Multiple options provided
- Truthfulness maintained
- Rationales clear

Test 6: Multi-format Generation

- Generate MD, DOCX, PDF, Report
- Verify formatting consistency
PASS CRITERIA:
- All formats readable
- Formatting professional
- Content identical across formats

Regression Testing:

After any SKILL.md changes:
1. Re-run Test 1 (happy path)
2. Verify no functionality broken
3. Commit only if passes

Repository: varunr89/resume-tailoring-skill
Commit: 9a4a0f2

Last updated: 24 days ago
Created: 24 days ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.