Skip to content
Back to search

resume-tailoring-skill

Claude skill for tailoring resumes to job descriptions using your existing markdown resume library. Researches the role and company, surfaces relevant real experience, scores fit, and generates truthful resumes for single jobs or small job batches.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/amanattar--resume-tailoring-skill/badge.svg)](/listings/amanattar--resume-tailoring-skill)

HTML

<a href="/listings/amanattar--resume-tailoring-skill"><img src="/api/listings/amanattar--resume-tailoring-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

In Claude's skill installer or web interface, use this repository directly.

For manual installation, the repo contents should end up in:

~/.claude/skills/resume-tailoring/

The required file is:

- `SKILL.md`

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 1,319 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: resume-tailoring
  3. description: 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
  4. ---
  5. # Resume Tailoring Skill
  6. ## Overview
  7. 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.
  8. **Core Principle:** Truth-preserving optimization - maximize fit while maintaining factual integrity. Never fabricate experience, but intelligently reframe and emphasize relevant aspects.
  9. **Mission:** A person's ability to get a job should be based on their experiences and capabilities, not on their resume writing skills.
  10. ## When to Use
  11. Use this skill when:
  12. - User provides a job description and wants a tailored resume
  13. - User has multiple existing resumes in markdown format
  14. - User wants to optimize their application for a specific role/company
  15. - User needs help surfacing and articulating undocumented experiences
  16. **DO NOT use for:**
  17. - Generic resume writing from scratch (user needs existing resume library)
  18. - Cover letters (different skill)
  19. - LinkedIn profile optimization (different skill)
  20. ## Quick Start
  21. **Required from user:**
  22. 1. Job description (text or URL)
  23. 2. Resume library location (defaults to `resumes/` in current directory)
  24. **Workflow:**
  25. 1. Build library from existing resumes
  26. 2. Research company/role
  27. 3. Create template (with user checkpoint)
  28. 4. Optional: Branching experience discovery
  29. 5. Match content with confidence scoring
  30. 6. Generate MD + DOCX + PDF + Report
  31. 7. User review → Optional library update
  32. ## Implementation
  33. See supporting files:
  34. - `research-prompts.md` - Structured prompts for company/role research
  35. - `matching-strategies.md` - Content matching algorithms and scoring
  36. - `branching-questions.md` - Experience discovery conversation patterns
  37. ## Workflow Details
  38. ### Multi-Job Detection
  39. **Triggers when user provides:**
  40. - Multiple JD URLs (comma or newline separated)
  41. - Phrases: "multiple jobs", "several positions", "batch", "3 jobs"
  42. - List of companies/roles: "Microsoft PM, Google TPM, AWS PM"
  43. **Detection Logic:**
  44. ```python
  45. # Pseudo-code
  46. def detect_multi_job(user_input):
  47. indicators = [
  48. len(extract_urls(user_input)) > 1,
  49. any(phrase in user_input.lower() for phrase in
  50. ["multiple jobs", "several positions", "batch of", "3 jobs", "5 jobs"]),
  51. count_company_mentions(user_input) > 1
  52. ]
  53. return any(indicators)
  54. ```
  55. **If detected:**
  56. ```
  57. "I see you have multiple job applications. Would you like to use
  58. multi-job mode?
  59. BENEFITS:
  60. - Shared experience discovery (faster - ask questions once for all jobs)
  61. - Batch processing with progress tracking
  62. - Incremental additions (add more jobs later)
  63. TIME COMPARISON (3 similar jobs):
  64. - Sequential single-job: ~45 minutes (15 min × 3)
  65. - Multi-job mode: ~40 minutes (15 min discovery + 8 min per job)
  66. Use multi-job mode? (Y/N)"
  67. ```
  68. **If user confirms Y:**
  69. - Use multi-job workflow (see multi-job-workflow.md)
  70. **If user confirms N or single job detected:**
  71. - Use existing single-job workflow (Phase 0 onwards)
  72. **Backward Compatibility:** Single-job workflow completely unchanged.
  73. **Multi-Job Workflow:**
  74. When multi-job mode is activated, see `multi-job-workflow.md` for complete workflow.
  75. **High-Level Multi-Job Process:**
  76. ```
  77. ┌─────────────────────────────────────────────────────────────┐
  78. │ PHASE 0: Intake & Batch Initialization │
  79. │ - Collect 3-5 job descriptions │
  80. │ - Initialize batch structure │
  81. │ - Run library initialization (once) │
  82. └─────────────────────────────────────────────────────────────┘
  83. ↓
  84. ┌─────────────────────────────────────────────────────────────┐
  85. │ PHASE 1: Aggregate Gap Analysis │
  86. │ - Extract requirements from all JDs │
  87. │ - Cross-reference against library │
  88. │ - Build unified gap map (deduplicate) │
  89. │ - Prioritize: Critical → Important → Job-specific │
  90. └─────────────────────────────────────────────────────────────┘
  91. ↓
  92. ┌─────────────────────────────────────────────────────────────┐
  93. │ PHASE 2: Shared Experience Discovery │
  94. │ - Single branching interview covering ALL gaps │
  95. │ - Multi-job context for each question │
  96. │ - Tag experiences with job relevance │
  97. │ - Enrich library with discoveries │
  98. └─────────────────────────────────────────────────────────────┘
  99. ↓
  100. ┌─────────────────────────────────────────────────────────────┐
  101. │ PHASE 3: Per-Job Processing (Sequential) │
  102. │ For each job: │
  103. │ ├─ Research (company + role benchmarking) │
  104. │ ├─ Template generation │
  105. │ ├─ Content matching (uses enriched library) │
  106. │ └─ Generation (MD + DOCX + Report) │
  107. │ Interactive or Express mode │
  108. └─────────────────────────────────────────────────────────────┘
  109. ↓
  110. ┌─────────────────────────────────────────────────────────────┐
  111. │ PHASE 4: Batch Finalization │
  112. │ - Generate batch summary │
  113. │ - User reviews all resumes together │
  114. │ - Approve/revise individual or batch │
  115. │ - Update library with approved resumes │
  116. └─────────────────────────────────────────────────────────────┘
  117. ```
  118. **Time Savings:**
  119. - 3 jobs: ~40 min (vs 45 min sequential) = 11% savings
  120. - 5 jobs: ~55 min (vs 75 min sequential) = 27% savings
  121. **Quality:** Same depth as single-job workflow (research, matching, generation)
  122. **See `multi-job-workflow.md` for complete implementation details.**
  123. ### Phase 0: Library Initialization
  124. **Always runs first - builds fresh resume database**
  125. **Process:**
  126. 1. **Locate resume directory:**
  127. ```
  128. User provides path OR default to ./resumes/
  129. Validate directory exists
  130. ```
  131. 2. **Scan for markdown files:**
  132. ```
  133. Use Glob tool: pattern="*.md" path={resume_directory}
  134. Count files found
  135. Announce: "Building resume library... found {N} resumes"
  136. ```
  137. 3. **Parse each resume:**
  138. For each resume file:
  139. - Use Read tool to load content
  140. - Extract sections: roles, bullets, skills, education
  141. - Identify patterns: bullet structure, length, formatting
  142. 4. **Build experience database structure:**
  143. ```json
  144. {
  145. "roles": [
  146. {
  147. "role_id": "company_title_year",
  148. "company": "Company Name",
  149. "title": "Job Title",
  150. "dates": "YYYY-YYYY",
  151. "description": "Role summary",
  152. "bullets": [
  153. {
  154. "text": "Full bullet text",
  155. "themes": ["leadership", "technical"],
  156. "metrics": ["17x improvement", "$3M revenue"],
  157. "keywords": ["cross-functional", "program"],
  158. "source_resumes": ["resume1.md"]
  159. }
  160. ]
  161. }
  162. ],
  163. "skills": {
  164. "technical": ["Python", "Kusto", "AI/ML"],
  165. "product": ["Roadmap", "Strategy"],
  166. "leadership": ["Stakeholder mgmt"]
  167. },
  168. "education": [...],
  169. "user_preferences": {
  170. "typical_length": "1-page|2-page",
  171. "section_order": ["summary", "experience", "education"],
  172. "bullet_style": "pattern"
  173. }
  174. }
  175. ```
  176. 5. **Tag content automatically:**
  177. - Themes: Scan for keywords (leadership, technical, analytics, etc.)
  178. - Metrics: Extract numbers, percentages, dollar amounts
  179. - Keywords: Frequent technical terms, action verbs
  180. **Output:** In-memory database ready for matching
  181. **Code pattern:**
  182. ```python
  183. # Pseudo-code for reference
  184. library = {
  185. "roles": [],
  186. "skills": {},
  187. "education": []
  188. }
  189. for resume_file in glob("resumes/*.md"):
  190. content = read(resume_file)
  191. roles = extract_roles(content)
  192. for role in roles:
  193. role["bullets"] = tag_bullets(role["bullets"])
  194. library["roles"].append(role)
  195. return library
  196. ```
  197. ### Phase 1: Research Phase
  198. **Goal:** Build comprehensive "success profile" beyond just the job description
  199. **Inputs:**
  200. - Job description (text or URL from user)
  201. - Optional: Company name if not in JD
  202. **Process:**
  203. **1.1 Job Description Parsing:**
  204. ```
  205. Use research-prompts.md JD parsing template
  206. Extract: requirements, keywords, implicit preferences, red flags, role archetype
  207. ```
  208. **1.2 Company Research:**
  209. ```
  210. WebSearch queries:
  211. - "{company} mission values culture"
  212. - "{company} engineering blog"
  213. - "{company} recent news"
  214. Synthesize: mission, values, business model, stage
  215. ```
  216. **1.3 Role Benchmarking:**
  217. ```
  218. WebSearch: "site:linkedin.com {job_title} {company}"
  219. WebFetch: Top 3-5 profiles
  220. Analyze: common backgrounds, skills, terminology
  221. If sparse results, try similar companies
  222. ```
  223. **1.4 Success Profile Synthesis:**
  224. ```
  225. Combine all research into structured profile (see research-prompts.md template)
  226. Include:
  227. - Core requirements (must-have)
  228. - Valued capabilities (nice-to-have)
  229. - Cultural fit signals
  230. - Narrative themes
  231. - Terminology map (user's background → their language)
  232. - Risk factors + mitigations
  233. ```
  234. **Checkpoint:**
  235. ```
  236. Present success profile to user:
  237. "Based on my research, here's what makes candidates successful for this role:
  238. {SUCCESS_PROFILE_SUMMARY}
  239. Key findings:
  240. - {Finding 1}
  241. - {Finding 2}
  242. - {Finding 3}
  243. Does this match your understanding? Any adjustments?"
  244. Wait for user confirmation before proceeding.
  245. ```
  246. **Output:** Validated success profile document
  247. ### Phase 2: Template Generation
  248. **Goal:** Create resume structure optimized for this specific role
  249. **Inputs:**
  250. - Success profile (from Phase 1)
  251. - User's resume library (from Phase 0)
  252. **Process:**
  253. **2.1 Analyze User's Resume Library:**
  254. ```
  255. Extract from library:
  256. - All roles, titles, companies, date ranges
  257. - Role archetypes (technical contributor, manager, researcher, specialist)
  258. - Experience clusters (what domains/skills appear frequently)
  259. - Career progression and narrative
  260. ```
  261. **2.2 Role Consolidation Decision:**
  262. **When to consolidate:**
  263. - Same company, similar responsibilities
  264. - Target role values continuity over granular progression
  265. - Combined narrative stronger than separate
  266. - Page space constrained
  267. **When to keep separate:**
  268. - Different companies (ALWAYS separate)
  269. - Dramatically different responsibilities that both matter
  270. - Target role values specific progression story
  271. - One position has significantly more relevant experience
  272. **Decision template:**
  273. ```
  274. For {Company} with {N} positions:
  275. OPTION A (Consolidated):
  276. Title: "{Combined_Title}"
  277. Dates: "{First_Start} - {Last_End}"
  278. Rationale: {Why consolidation makes sense}
  279. OPTION B (Separate):
  280. Position 1: "{Title}" ({Dates})
  281. Position 2: "{Title}" ({Dates})
  282. Rationale: {Why separate makes sense}
  283. RECOMMENDED: Option {A/B} because {reasoning}
  284. ```
  285. **2.3 Title Reframing Principles:**
  286. **Core rule:** Stay truthful to what you did, emphasize aspect most relevant to target
  287. **Strategies:**
  288. 1. **Emphasize different aspects:**
  289. - "Graduate Researcher" → "Research Software Engineer" (if coding-heavy)
  290. - "Data Science Lead" → "Technical Program Manager" (if leadership)
  291. 2. **Use industry-standard terminology:**
  292. - "Scientist III" → "Senior Research Scientist" (clearer seniority)
  293. - "Program Coordinator" → "Project Manager" (standard term)
  294. 3. **Add specialization when truthful:**
  295. - "Engineer" → "ML Engineer" (if ML work substantial)
  296. - "Researcher" → "Computational Ecologist" (if computational methods)
  297. 4. **Adjust seniority indicators:**
  298. - "Lead" vs "Senior" vs "Staff" based on scope
  299. **Constraints:**
  300. - NEVER claim work you didn't do
  301. - NEVER inflate seniority beyond defensible
  302. - Company name and dates MUST be exact
  303. - Core responsibilities MUST be accurate
  304. **2.4 Generate Template Structure:**
  305. ```markdown
  306. ## Professional Summary
  307. [GUIDANCE: {X} sentences emphasizing {themes from success profile}]
  308. [REQUIRED ELEMENTS: {keywords from JD}]
  309. ## Key Skills
  310. [STRUCTURE: {2-4 categories based on JD structure}]
  311. [SOURCE: Extract from library matching success profile]
  312. ## Professional Experience
  313. ### [ROLE 1 - Most Recent/Relevant]
  314. [CONSOLIDATION: {merge X positions OR keep separate}]
  315. [TITLE OPTIONS:
  316. A: {emphasize aspect 1}
  317. B: {emphasize aspect 2}
  318. Recommended: {option with rationale}]
  319. [BULLET ALLOCATION: {N bullets based on relevance + recency}]
  320. [GUIDANCE: Emphasize {themes}, look for {experience types}]
  321. Bullet 1: [SEEKING: {requirement type}]
  322. Bullet 2: [SEEKING: {requirement type}]
  323. ...
  324. ### [ROLE 2]
  325. ...
  326. ## Education
  327. [PLACEMENT: {top if required/recent, bottom if experience-heavy}]
  328. ## [Optional Sections]
  329. [INCLUDE IF: {criteria from success profile}]
  330. ```
  331. **Checkpoint:**
  332. ```
  333. Present template to user:
  334. "Here's the optimized resume structure for this role:
  335. STRUCTURE:
  336. {Section order and rationale}
  337. ROLE CONSOLIDATION:
  338. {Decisions with options}
  339. TITLE REFRAMING:
  340. {Proposed titles with alternatives}
  341. BULLET ALLOCATION:
  342. Role 1: {N} bullets (most relevant)
  343. Role 2: {N} bullets
  344. ...
  345. Does this structure work? Any adjustments to:
  346. - Role consolidation?
  347. - Title reframing?
  348. - Bullet allocation?"
  349. Wait for user approval before proceeding.
  350. ```
  351. **Output:** Approved template skeleton with guidance for each section
  352. ### Phase 2.5: Experience Discovery (OPTIONAL)
  353. **Goal:** Surface undocumented experiences through conversational discovery
  354. **When to trigger:**
  355. ```
  356. After template approval, if gaps identified:
  357. "I've identified {N} gaps or areas where we have weak matches:
  358. - {Gap 1}: {Current confidence}
  359. - {Gap 2}: {Current confidence}
  360. ...
  361. Would you like to do a structured brainstorming session to surface
  362. any experiences you haven't documented yet?
  363. This typically takes 10-15 minutes and often uncovers valuable content."
  364. User can accept or skip.
  365. ```
  366. **Branching Interview Process:**
  367. **Approach:** Conversational with follow-up questions based on answers
  368. **For each gap, conduct branching dialogue (see branching-questions.md):**
  369. 1. **Start with open probe:**
  370. - Technical gap: "Have you worked with {skill}?"
  371. - Soft skill gap: "Tell me about times you've {demonstrated_skill}"
  372. - Recent work: "What have you worked on recently?"
  373. 2. **Branch based on answer:**
  374. - YES/Strong → Deep dive (scale, challenges, metrics)
  375. - INDIRECT → Explore role and transferability
  376. - ADJACENT → Explore related experience
  377. - PERSONAL → Assess recency and substance
  378. - NO → Try broader category or move on
  379. 3. **Follow-up systematically:**
  380. - Ask "what," "how," "why" to get details
  381. - Quantify: "Any metrics?"
  382. - Contextualize: "Was this production?"
  383. - Validate: "Does this address the gap?"
  384. 4. **Capture immediately:**
  385. - Document experience as shared
  386. - Ask clarifying questions (dates, scope, impact)
  387. - Help articulate as resume bullet
  388. - Tag which gap(s) it addresses
  389. **Capture Structure:**
  390. ```markdown
  391. ## Newly Discovered Experiences
  392. ### Experience 1: {Brief description}
  393. - Context: {Where/when}
  394. - Scope: {Scale, duration, impact}
  395. - Addresses: {Which gaps}
  396. - Bullet draft: "{Achievement-focused bullet}"
  397. - Confidence: {How well fills gap - percentage}
  398. ### Experience 2: ...
  399. ```
  400. **Integration Options:**
  401. After discovery session:
  402. ```
  403. "Great! I captured {N} new experiences. For each one:
  404. 1. ADD TO CURRENT RESUME - Integrate now
  405. 2. ADD TO LIBRARY ONLY - Save for future, not needed here
  406. 3. REFINE FURTHER - Think more about articulation
  407. 4. DISCARD - Not relevant enough
  408. Let me know for each experience."
  409. ```
  410. **Important Notes:**
  411. - Keep truthfulness bar high - help articulate, NEVER fabricate
  412. - Focus on gaps and weak matches, not strong areas
  413. - Time-box if needed (10-15 minutes typical)
  414. - User can skip entirely if confident in library
  415. - Recognize when to move on - don't exhaust user
  416. **Output:** New experiences integrated into library, ready for matching
  417. ### Phase 3: Assembly Phase
  418. **Goal:** Fill approved template with best-matching content, with transparent scoring
  419. **Inputs:**
  420. - Approved template (from Phase 2)
  421. - Resume library + discovered experiences (from Phase 0 + 2.5)
  422. - Success profile (from Phase 1)
  423. **Process:**
  424. **3.1 For Each Template Slot:**
  425. 1. **Extract all candidate bullets from library**
  426. - All bullets from library database
  427. - All newly discovered experiences
  428. - Include source resume for each
  429. 2. **Score each candidate** (see matching-strategies.md)
  430. - Direct match (40%): Keywords, domain, technology, outcome
  431. - Transferable (30%): Same capability, different context
  432. - Adjacent (20%): Related tools, methods, problem space
  433. - Impact (10%): Achievement type alignment
  434. Overall = (Direct × 0.4) + (Transfer × 0.3) + (Adjacent × 0.2) + (Impact × 0.1)
  435. 3. **Rank candidates by score**
  436. - Sort high to low
  437. - Group by confidence band:
  438. * 90-100%: DIRECT
  439. * 75-89%: TRANSFERABLE
  440. * 60-74%: ADJACENT
  441. * <60%: WEAK/GAP
  442. 4. **Present top 3 matches with analysis:**
  443. ```
  444. TEMPLATE SLOT: {Role} - Bullet {N}
  445. SEEKING: {Requirement description}
  446. MATCHES:
  447. [DIRECT - 95%] "{bullet_text}"
  448. ✓ Direct: {what matches directly}
  449. ✓ Transferable: {what transfers}
  450. ✓ Metrics: {quantified impact}
  451. Source: {resume_name}
  452. [TRANSFERABLE - 78%] "{bullet_text}"
  453. ✓ Transferable: {what transfers}
  454. ✓ Adjacent: {what's adjacent}
  455. ⚠ Gap: {what's missing}
  456. Source: {resume_name}
  457. [ADJACENT - 62%] "{bullet_text}"
  458. ✓ Adjacent: {what's related}
  459. ⚠ Gap: {what's missing}
  460. Source: {resume_name}
  461. RECOMMENDATION: Use DIRECT match (95%)
  462. ALTERNATIVE: If avoiding repetition, use TRANSFERABLE (78%) with reframing
  463. ```
  464. 5. **Handle gaps (confidence <60%):**
  465. ```
  466. GAP IDENTIFIED: {Requirement}
  467. BEST AVAILABLE: {score}% - "{bullet_text}"
  468. REFRAME OPPORTUNITY: {If applicable}
  469. Original: "{text}"
  470. Reframed: "{adjusted_text}" (truthful because {reason})
  471. New confidence: {score}%
  472. OPTIONS:
  473. 1. Use reframed version ({new_score}%)
  474. 2. Acknowledge gap in cover letter
  475. 3. Omit bullet slot (reduce allocation)
  476. 4. Use best available with disclosure
  477. RECOMMENDATION: {Most appropriate option}
  478. ```
  479. **3.2 Content Reframing:**
  480. When good match (>60%) but terminology misaligned:
  481. **Apply strategies from matching-strategies.md:**
  482. - Keyword alignment (preserve meaning, adjust terms)
  483. - Emphasis shift (same facts, different focus)
  484. - Abstraction level (adjust technical specificity)
  485. - Scale emphasis (highlight relevant aspects)
  486. **Show before/after for transparency:**
  487. ```
  488. REFRAMING APPLIED:
  489. Bullet: {template_slot}
  490. Original: "{original_bullet}"
  491. Source: {resume_name}
  492. Reframed: "{reframed_bullet}"
  493. Changes: {what changed and why}
  494. Truthfulness: {why this is accurate}
  495. ```
  496. **Checkpoint:**
  497. ```
  498. "I've matched content to your template. Here's the complete mapping:
  499. COVERAGE SUMMARY:
  500. - Direct matches: {N} bullets ({percentage}%)
  501. - Transferable: {N} bullets ({percentage}%)
  502. - Adjacent: {N} bullets ({percentage}%)
  503. - Gaps: {N} ({percentage}%)
  504. REFRAMINGS APPLIED: {N}
  505. - {Example 1}
  506. - {Example 2}
  507. GAPS IDENTIFIED:
  508. - {Gap 1}: {Recommendation}
  509. - {Gap 2}: {Recommendation}
  510. OVERALL JD COVERAGE: {percentage}%
  511. Review the detailed mapping below. Any adjustments to:
  512. - Match selections?
  513. - Reframings?
  514. - Gap handling?"
  515. [Present full detailed mapping]
  516. Wait for user approval before generation.
  517. ```
  518. **Output:** Complete bullet-by-bullet mapping with confidence scores and reframings
  519. ### Phase 4: Generation Phase
  520. **Goal:** Create professional multi-format outputs
  521. **Inputs:**
  522. - Approved content mapping (from Phase 3)
  523. - User's formatting preferences (from library analysis)
  524. - Target role information (from Phase 1)
  525. **Process:**
  526. **4.1 Markdown Generation:**
  527. **Compile mapped content into clean markdown:**
  528. ```markdown
  529. # {User_Name}
  530. {Contact_Info}
  531. ---
  532. ## Professional Summary
  533. {Summary_from_template}
  534. ---
  535. ## Key Skills
  536. **{Category_1}:**
  537. - {Skills_from_library_matching_profile}
  538. **{Category_2}:**
  539. - {Skills_from_library_matching_profile}
  540. {Repeat for all categories}
  541. ---
  542. ## Professional Experience
  543. ### {Job_Title}
  544. **{Company} | {Location} | {Dates}**
  545. {Role_summary_if_applicable}
  546. • {Bullet_1_from_mapping}
  547. • {Bullet_2_from_mapping}
  548. ...
  549. ### {Next_Role}
  550. ...
  551. ---
  552. ## Education
  553. **{Degree}** | {Institution} ({Year})
  554. **{Degree}** | {Institution} ({Year})
  555. ```
  556. **Use user's preferences:**
  557. - Formatting style from library analysis
  558. - Bullet structure pattern
  559. - Section ordering
  560. - Typical length (1-page vs 2-page)
  561. **Output:** `{Name}_{Company}_{Role}_Resume.md`
  562. **4.2 DOCX Generation:**
  563. **Use document-skills:docx:**
  564. ```
  565. REQUIRED SUB-SKILL: Use document-skills:docx
  566. Create Word document with:
  567. - Professional fonts (Calibri 11pt body, 12pt headers)
  568. - Proper spacing (single within sections, space between)
  569. - Clean bullet formatting (proper numbering config, NOT unicode)
  570. - Header with contact information
  571. - Appropriate margins (0.5-1 inch)
  572. - Bold/italic emphasis (company names, titles, dates)
  573. - Page breaks if 2-page resume
  574. See docx skill documentation for:
  575. - Paragraph and TextRun structure
  576. - Numbering configuration for bullets
  577. - Heading levels and styles
  578. - Spacing and margins
  579. ```
  580. **Output:** `{Name}_{Company}_{Role}_Resume.docx`
  581. **4.3 PDF Generation (Optional):**
  582. **If user requests PDF:**
  583. ```
  584. OPTIONAL SUB-SKILL: Use document-skills:pdf
  585. Convert DOCX to PDF OR generate directly
  586. Ensure formatting preservation
  587. Professional appearance for direct submission
  588. ```
  589. **Output:** `{Name}_{Company}_{Role}_Resume.pdf`
  590. **4.4 Generation Summary Report:**
  591. **Create metadata file:**
  592. ```markdown
  593. # Resume Generation Report
  594. **{Role} at {Company}**
  595. **Date Generated:** {timestamp}
  596. ## Target Role Summary
  597. - Company: {Company}
  598. - Position: {Role}
  599. - IC Level: {If known}
  600. - Focus Areas: {Key areas}
  601. ## Success Profile Summary
  602. - Key Requirements: {top 5}
  603. - Cultural Fit Signals: {themes}
  604. - Risk Factors Addressed: {mitigations}
  605. ## Content Mapping Summary
  606. - Total bullets: {N}
  607. - Direct matches: {N} ({percentage}%)
  608. - Transferable: {N} ({percentage}%)
  609. - Adjacent: {N} ({percentage}%)
  610. - Gaps identified: {list}
  611. ## Reframing Applied
  612. - {bullet}: {original} → {reframed} [Reason: {why}]
  613. ...
  614. ## Source Resumes Used
  615. - {resume1}: {N} bullets
  616. - {resume2}: {N} bullets
  617. ...
  618. ## Gaps Addressed
  619. ### Before Experience Discovery:
  620. {Gap analysis showing initial state}
  621. ### After Experience Discovery:
  622. {Gap analysis showing final state}
  623. ### Remaining Gaps:
  624. {Any unresolved gaps with recommendations}
  625. ## Key Differentiators for This Role
  626. {What makes user uniquely qualified}
  627. ## Recommendations for Interview Prep
  628. - Stories to prepare
  629. - Questions to expect
  630. - Gaps to address
  631. ```
  632. **Output:** `{Name}_{Company}_{Role}_Resume_Report.md`
  633. **Present to user:**
  634. ```
  635. "Your tailored resume has been generated!
  636. FILES CREATED:
  637. - {Name}_{Company}_{Role}_Resume.md
  638. - {Name}_{Company}_{Role}_Resume.docx
  639. - {Name}_{Company}_{Role}_Resume_Report.md
  640. {- {Name}_{Company}_{Role}_Resume.pdf (if requested)}
  641. QUALITY METRICS:
  642. - JD Coverage: {percentage}%
  643. - Direct Matches: {percentage}%
  644. - Newly Discovered: {N} experiences
  645. Review the files and let me know:
  646. 1. Save to library (recommended)
  647. 2. Need revisions
  648. 3. Save but don't add to library"
  649. ```
  650. ### Phase 5: Library Update (CONDITIONAL)
  651. **Goal:** Optionally add successful resume to library for future use
  652. **When:** After user reviews and approves generated resume
  653. **Checkpoint Question:**
  654. ```
  655. "Are you satisfied with this resume?
  656. OPTIONS:
  657. 1. YES - Save to library
  658. → Adds resume to permanent location
  659. → Rebuilds library database
  660. → Makes new content available for future resumes
  661. 2. NO - Need revisions
  662. → What would you like to adjust?
  663. → Make changes and re-present
  664. 3. SAVE BUT DON'T ADD TO LIBRARY
  665. → Keep files in current location
  666. → Don't enrich database
  667. → Useful for experimental resumes
  668. Which option?"
  669. ```
  670. **If Option 1 (YES - Save to library):**
  671. **Process:**
  672. 1. **Move resume to library:**
  673. ```
  674. Source: {current_directory}/{Name}_{Company}_{Role}_Resume.md
  675. Destination: {resume_library}/{Name}_{Company}_{Role}_Resume.md
  676. Also move:
  677. - .docx file
  678. - .pdf file (if exists)
  679. - _Report.md file
  680. ```
  681. 2. **Rebuild library database:**
  682. ```
  683. Re-run Phase 0 library initialization
  684. Parse newly created resume
  685. Add bullets to experience database
  686. Update keyword/theme indices
  687. Tag with metadata:
  688. - target_company: {Company}
  689. - target_role: {Role}
  690. - generated_date: {timestamp}
  691. - jd_coverage: {percentage}
  692. - success_profile: {reference to profile}
  693. ```
  694. 3. **Preserve generation metadata:**
  695. ```json
  696. {
  697. "resume_id": "{Name}_{Company}_{Role}",
  698. "generated": "{timestamp}",
  699. "source_resumes": ["{resume1}", "{resume2}"],
  700. "reframings": [
  701. {
  702. "original": "{text}",
  703. "reframed": "{text}",
  704. "reason": "{why}"
  705. }
  706. ],
  707. "match_scores": {
  708. "bullet_1": 95,
  709. "bullet_2": 87,
  710. ...
  711. },
  712. "newly_discovered": [
  713. {
  714. "experience": "{description}",
  715. "bullet": "{text}",
  716. "addresses_gap": "{gap}"
  717. }
  718. ]
  719. }
  720. ```
  721. 4. **Announce completion:**
  722. ```
  723. "Resume saved to library!
  724. Library updated:
  725. - Total resumes: {N}
  726. - New content variations: {N}
  727. - Newly discovered experiences added: {N}
  728. This resume and its new content are now available for future tailoring sessions."
  729. ```
  730. **If Option 2 (NO - Need revisions):**
  731. ```
  732. "What would you like to adjust?"
  733. [Collect user feedback]
  734. [Make requested changes]
  735. [Re-run relevant phases]
  736. [Re-present for approval]
  737. [Repeat until satisfied or user cancels]
  738. ```
  739. **If Option 3 (SAVE BUT DON'T ADD TO LIBRARY):**
  740. ```
  741. "Resume files saved to current directory:
  742. - {Name}_{Company}_{Role}_Resume.md
  743. - {Name}_{Company}_{Role}_Resume.docx
  744. - {Name}_{Company}_{Role}_Resume_Report.md
  745. Not added to library - you can manually move later if desired."
  746. ```
  747. **Benefits of Library Update:**
  748. - Grows library with each successful resume
  749. - New bullet variations become available
  750. - Reframings that work can be reused
  751. - Discovered experiences permanently captured
  752. - Future sessions start with richer library
  753. - Self-improving system over time
  754. **Output:** Updated library database + metadata preservation (if Option 1)
  755. ## Error Handling & Edge Cases
  756. **Edge Case 1: Insufficient Resume Library**
  757. ```
  758. SCENARIO: User has only 1-2 resumes, limited content
  759. HANDLING:
  760. "⚠️ Limited resume library detected ({N} resumes).
  761. This may result in:
  762. - Fewer matching options
  763. - More gaps in coverage
  764. - Less variety in bullet phrasing
  765. RECOMMENDATIONS:
  766. - Proceed with available content (I'll do my best!)
  767. - Consider adding more resumes after this generation
  768. - Experience Discovery phase will be especially valuable
  769. Continue? (Y/N)"
  770. ```
  771. **Edge Case 2: No Good Matches (confidence <60% for critical requirement)**
  772. ```
  773. SCENARIO: Template slot requires experience user doesn't have
  774. HANDLING:
  775. "❌ GAP: {Requirement}
  776. No matches found with confidence >60%
  777. OPTIONS:
  778. 1. Run Experience Discovery - might surface undocumented work
  779. 2. Reframe best available ({score}%) - I'll show you the reframing
  780. 3. Omit bullet slot - reduce template allocation
  781. 4. Note for cover letter - emphasize learning ability
  782. Which approach?"
  783. [Don't force matches - be transparent about gaps]
  784. ```
  785. **Edge Case 3: Research Phase Failures**
  786. ```
  787. SCENARIO: WebSearch fails, LinkedIn unavailable, company info sparse
  788. HANDLING:
  789. "⚠️ Limited company research available.
  790. What I found:
  791. - {Available info}
  792. What's missing:
  793. - {Missing areas}
  794. Falling back to job description-only analysis.
  795. Result: Template will be optimized for JD but may miss cultural nuances.
  796. Do you have additional context about:
  797. - Company culture?
  798. - Team structure?
  799. - Technologies used?
  800. (Optional - you can share or skip)"
  801. [Proceed with best-effort approach]
  802. ```
  803. **Edge Case 4: Job Description Quality Issues**
  804. ```
  805. SCENARIO: Vague JD, missing requirements, poorly written
  806. HANDLING:
  807. "⚠️ Job description lacks detail in areas:
  808. - {Missing area 1}
  809. - {Missing area 2}
  810. This may limit template optimization.
  811. Do you have additional context about:
  812. - {Question 1}
  813. - {Question 2}
  814. (Optional - I'll work with what's available)"
  815. [Extract what's possible, proceed]
  816. ```
  817. **Edge Case 5: Ambiguous Role Consolidation**
  818. ```
  819. SCENARIO: Unclear whether to merge roles or keep separate
  820. HANDLING:
  821. "🤔 Ambiguous consolidation decision for {Company}
  822. OPTION A (Consolidated): {Rationale}
  823. OPTION B (Separate): {Rationale}
  824. Both are defensible. Which do you prefer?
  825. (This becomes your preference for similar situations)"
  826. [Remember preference for future]
  827. ```
  828. **Edge Case 6: Resume Length Constraints**
  829. ```
  830. SCENARIO: Too much good content, exceeds 2 pages
  831. HANDLING:
  832. "⚠️ Content exceeds 2 pages (current: {N} bullets, ~{pages} pages)
  833. PRUNING SUGGESTIONS (ranked by relevance):
  834. Remove:
  835. - {Bullet X}: {score}% match (lowest)
  836. - {Bullet Y}: {score}% match
  837. ...
  838. Keep all bullets and accept >2 pages?
  839. OR
  840. Remove {N} bullets to fit 2 pages?
  841. Your preference?"
  842. [User decides priority]
  843. ```
  844. **Error Recovery:**
  845. - All checkpoints allow going back to previous phase
  846. - User can request adjustments at any checkpoint
  847. - Generation failures (DOCX/PDF) fall back to markdown-only
  848. - Progress saved between phases (can resume if interrupted)
  849. **Graceful Degradation:**
  850. - Research limited → Fall back to JD-only analysis
  851. - Library small → Work with available + emphasize discovery
  852. - Matches weak → Transparent gap identification
  853. - Generation fails → Provide markdown + error details
  854. ## Usage Examples
  855. **Example 1: Internal Role (Same Company)**
  856. ```
  857. USER: "I want to apply for Principal PM role in 1ES team at Microsoft.
  858. Here's the JD: {paste}"
  859. SKILL:
  860. 1. Library Build: Finds 29 resumes
  861. 2. Research: Microsoft 1ES team, internal culture, role benchmarking
  862. 3. Template: Features PM2 Azure Eng Systems role (most relevant)
  863. 4. Discovery: Surfaces VS Code extension, Bhavana AI side project
  864. 5. Assembly: 92% JD coverage, 75% direct matches
  865. 6. Generate: MD + DOCX + Report
  866. 7. User approves → Library updated with new resume + 6 discovered experiences
  867. RESULT: Highly competitive application leveraging internal experience
  868. ```
  869. **Example 2: Career Transition (Different Domain)**
  870. ```
  871. USER: "I'm a TPM trying to transition to ecology PM role. JD: {paste}"
  872. SKILL:
  873. 1. Library Build: Finds existing TPM resumes
  874. 2. Research: Ecology sector, sustainability focus, cross-domain transfers
  875. 3. Template: Reframes "Technical Program Manager" → "Program Manager,
  876. Environmental Systems" emphasizing systems thinking
  877. 4. Discovery: Surfaces volunteer conservation work, graduate research in
  878. environmental modeling
  879. 5. Assembly: 65% JD coverage - flags gaps in domain-specific knowledge
  880. 6. Generate: Resume + gap analysis with cover letter recommendations
  881. RESULT: Bridges technical skills with environmental domain
  882. ```
  883. **Example 3: Career Gap Handling**
  884. ```
  885. USER: "I have a 2-year gap while starting a company. JD: {paste}"
  886. SKILL:
  887. 1. Library Build: Finds pre-gap resumes
  888. 2. Research: Standard analysis
  889. 3. Template: Includes startup as legitimate role
  890. 4. Discovery: Surfaces skills developed during startup (fundraising,
  891. product development, team building)
  892. 5. Assembly: Frames gap as entrepreneurial experience
  893. 6. Generate: Resume presenting gap as valuable experience
  894. RESULT: Gap becomes strength showing initiative and diverse skills
  895. ```
  896. **Example 4: Multi-Job Batch (3 Similar Roles)**
  897. ```
  898. USER: "I want to apply for these 3 TPM roles:
  899. 1. Microsoft 1ES Principal PM
  900. 2. Google Cloud Senior TPM
  901. 3. AWS Container Services Senior PM
  902. Here are the JDs: {paste 3 JDs}"
  903. SKILL:
  904. 1. Multi-job detection: Triggered (3 JDs detected)
  905. 2. Intake: Collects all 3 JDs, initializes batch
  906. 3. Library Build: Finds 29 resumes (once)
  907. 4. Gap Analysis: Identifies 14 gaps, 8 unique after deduplication
  908. 5. Shared Discovery: 30-minute session surfaces 5 new experiences
  909. - Kubernetes CI/CD for nonprofits
  910. - Azure migration for university lab
  911. - Cross-functional team leadership examples
  912. - Recent hackathon project
  913. - Open source contributions
  914. 6. Per-Job Processing (×3):
  915. - Job 1 (Microsoft): 85% coverage, emphasizes Azure/1ES alignment
  916. - Job 2 (Google): 88% coverage, emphasizes technical depth
  917. - Job 3 (AWS): 78% coverage, addresses AWS gap in cover letter recs
  918. 7. Batch Finalization: All 3 resumes reviewed, approved, added to library
  919. RESULT: 3 high-quality resumes in 40 minutes vs 45 minutes sequential
  920. 5 new experiences captured, available for future applications
  921. Average coverage: 84%, all critical gaps resolved
  922. ```
  923. **Example 5: Incremental Batch Addition**
  924. ```
  925. WEEK 1:
  926. USER: "I want to apply for 3 jobs: {Microsoft, Google, AWS}"
  927. SKILL: [Processes batch as above, completes in 40 min]
  928. WEEK 2:
  929. USER: "I found 2 more jobs: Stripe and Meta. Add them to my batch?"
  930. SKILL:
  931. 1. Load existing batch (includes 5 previously discovered experiences)
  932. 2. Intake: Adds Job 4 (Stripe), Job 5 (Meta)
  933. 3. Incremental Gap Analysis: Only 3 new gaps (vs 14 original)
  934. - Payment systems (Stripe-specific)
  935. - Social networking (Meta-specific)
  936. - React/frontend (both)
  937. 4. Incremental Discovery: 10-minute session for new gaps only
  938. - Surfaces payment processing side project
  939. - React work from bootcamp
  940. - Large-scale system design course
  941. 5. Per-Job Processing (×2): Jobs 4, 5 processed independently
  942. 6. Updated Batch Summary: Now 5 jobs total, 8 experiences discovered
  943. RESULT: 2 additional resumes in 20 minutes (vs 30 min if starting from scratch)
  944. Time saved by not re-asking 8 previous gaps: ~20 minutes
  945. ```
  946. ## Testing Guidelines
  947. **Manual Testing Checklist:**
  948. **Test 1: Happy Path**
  949. ```
  950. - Provide JD with clear requirements
  951. - Library with 10+ resumes
  952. - Run all phases without skipping
  953. - Verify generated files
  954. - Check library update
  955. PASS CRITERIA:
  956. - All files generated correctly
  957. - JD coverage >70%
  958. - No errors in any phase
  959. ```
  960. **Test 2: Minimal Library**
  961. ```
  962. - Provide only 2 resumes
  963. - Run through workflow
  964. - Verify gap handling
  965. PASS CRITERIA:
  966. - Graceful warning about limited library
  967. - Still produces reasonable output
  968. - Gaps clearly identified
  969. ```
  970. **Test 3: Research Failures**
  971. ```
  972. - Use obscure company with minimal online presence
  973. - Verify fallback to JD-only
  974. PASS CRITERIA:
  975. - Warning about limited research
  976. - Proceeds with JD analysis
  977. - Template still reasonable
  978. ```
  979. **Test 4: Experience Discovery Value**
  980. ```
  981. - Run with deliberate gaps in library
  982. - Conduct experience discovery
  983. - Verify new experiences integrated
  984. PASS CRITERIA:
  985. - Discovers genuine undocumented experiences
  986. - Integrates into final resume
  987. - Improves JD coverage
  988. ```
  989. **Test 5: Title Reframing**
  990. ```
  991. - Test various role transitions
  992. - Verify title reframing suggestions
  993. PASS CRITERIA:
  994. - Multiple options provided
  995. - Truthfulness maintained
  996. - Rationales clear
  997. ```
  998. **Test 6: Multi-format Generation**
  999. ```
  1000. - Generate MD, DOCX, PDF, Report
  1001. - Verify formatting consistency
  1002. PASS CRITERIA:
  1003. - All formats readable
  1004. - Formatting professional
  1005. - Content identical across formats
  1006. ```
  1007. **Regression Testing:**
  1008. ```
  1009. After any SKILL.md changes:
  1010. 1. Re-run Test 1 (happy path)
  1011. 2. Verify no functionality broken
  1012. 3. Commit only if passes
  1013. ```
README.md · README · 23 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Resume Tailoring Skill
  2. Minimal standalone repo for Claude skill installation.
  3. ## Install
  4. In Claude's skill installer or web interface, use this repository directly.
  5. For manual installation, the repo contents should end up in:
  6. ```text
  7. ~/.claude/skills/resume-tailoring/
  8. ```
  9. The required file is:
  10. - `SKILL.md`
  11. ## Notes
  12. - This packaged repo keeps the skill self-contained.
  13. - The workflow covers single-job resume tailoring and small multi-job batches.
  14. - The skill assumes the user already has resume material in markdown.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.