Handles 3-5 similar jobs efficiently by consolidating experience discovery while maintaining per-job research depth.
Architecture: Shared Discovery + Per-Job Tailoring
Target Use Case:
- Small batches (3-5 jobs)
- Moderately similar roles (60%+ requirement overlap)
- Continuous workflow (add jobs incrementally)
Goal: Collect all job descriptions and initialize batch structure
User Interaction:
SKILL: "Let's set up your multi-job batch. How would you like to provide
the job descriptions?
1. Paste them all now (recommended for efficiency)
2. Provide one at a time
3. Provide URLs to fetch
For each job, I need:
- Job description (text or URL)
- Company name (if not in JD)
- Role title (if not in JD)
- Optional: Priority (high/medium/low) or notes"
Data Collection Loop:
For each job (until user says "done"):
- Collect JD text or URL
- Collect company name (extract from JD if possible, else ask)
- Collect role title (extract from JD if possible, else ask)
- Ask: "Priority for this job? (high/medium/low, default: medium)"
- Ask: "Any notes about this job? (optional, e.g., 'referral from X')"
- Assign job_id: "job-1", "job-2", etc.
- Set status: "pending"
- Add to batch
Quick JD Parsing:
For each job, lightweight extraction (NOT full research yet):
# Pseudo-code
def quick_parse_jd(jd_text):
return {
"requirements_must_have": extract_requirements(jd_text, required=True),
"requirements_nice_to_have": extract_requirements(jd_text, required=False),
"technical_skills": extract_technical_keywords(jd_text),
"soft_skills": extract_soft_skills(jd_text),
"domain_areas": identify_domains(jd_text)
}Purpose: Just enough to identify gaps for discovery phase. Full research happens per-job later.
Batch Initialization:
Create batch directory structure:
resumes/batches/batch-{YYYY-MM-DD}-{slug}/
├── _batch_state.json # State tracking
├── _aggregate_gaps.md # Gap analysis (created in Phase 1)
├── _discovered_experiences.md # Discovery output (created in Phase 2)
└── (job directories created during per-job processing)
Initialize _batch_state.json:
{
"batch_id": "batch-2025-11-04-job-search",
"created": "2025-11-04T10:30:00Z",
"current_phase": "intake",
"processing_mode": "interactive",
"jobs": [
{
"job_id": "job-1",
"company": "Microsoft",
"role": "Principal PM - 1ES",
"jd_text": "...",
"jd_url": "https://...",
"priority": "high",
"notes": "Internal referral from Alice",
"status": "pending",
"requirements": ["Kubernetes", "CI/CD", "Leadership"],
"gaps": []
}
],
"discoveries": [],
"aggregate_gaps": {}
}Library Initialization:
Run standard Phase 0 from SKILL.md (library initialization) once for the entire batch.
Output:
"Batch initialized with {N} jobs:
- Job 1: {Company} - {Role} (priority: {priority})
- Job 2: {Company} - {Role}
...
Next: Aggregate gap analysis across all jobs.
Continue? (Y/N)"
Checkpoint: User confirms batch is complete before proceeding.
Goal: Build unified gap list across all jobs to guide single efficient discovery session
Process:
1.1 Extract Requirements from All JDs:
For each job:
- Parse requirements (already done in Phase 0 quick parse)
- Categorize: must-have vs nice-to-have
- Extract keywords and skill areas
Example output:
Job 1 (Microsoft 1ES): Kubernetes, CI/CD, cross-functional leadership, Azure
Job 2 (Google Cloud): Kubernetes, GCP, distributed systems, team management
Job 3 (AWS): Container orchestration, AWS services, program management
1.2 Match Against Resume Library:
For each requirement across ALL jobs:
- Search library for matching experiences (using matching-strategies.md)
- Score confidence (0-100%)
- Flag as gap if confidence < 60%
# Pseudo-code
for job in batch.jobs:
for requirement in job.requirements:
matches = search_library(requirement)
best_score = max(match.score for match in matches)
if best_score < 60:
flag_as_gap(requirement, best_score, job.job_id)1.3 Build Aggregate Gap Map:
Deduplicate gaps across jobs and prioritize:
# Pseudo-code
def build_aggregate_gaps(all_gaps):
gap_map = {}
for gap in all_gaps:
if gap.name not in gap_map:
gap_map[gap.name] = {
"appears_in_jobs": [],
"best_match": gap.confidence,
"priority": 0
}
gap_map[gap.name]["appears_in_jobs"].append(gap.job_id)
# Prioritize
for gap_name, gap_data in gap_map.items():
job_count = len(gap_data["appears_in_jobs"])
if job_count >= 3:
gap_data["priority"] = 3 # Critical
elif job_count == 2:
gap_data["priority"] = 2 # Important
else:
gap_data["priority"] = 1 # Job-specific
return gap_map1.4 Create Gap Analysis Report:
Generate _aggregate_gaps.md:
# Aggregate Gap Analysis
**Batch:** batch-2025-11-04-job-search
**Generated:** 2025-11-04T11:00:00Z
## Coverage Summary
- Job 1 (Microsoft): 68% coverage, 5 gaps
- Job 2 (Google): 72% coverage, 4 gaps
- Job 3 (AWS): 65% coverage, 6 gaps
## Critical Gaps (appear in 3+ jobs)
### Kubernetes at scale
- **Appears in:** Jobs 1, 2, 3
- **Current best match:** 45% confidence
- **Match source:** "Deployed containerized app for nonprofit" (2023)
- **Gap:** No production Kubernetes management at scale
### CI/CD pipeline management
- **Appears in:** Jobs 1, 2, 3
- **Current best match:** 58% confidence
- **Match source:** "Set up GitHub Actions workflow" (2024)
- **Gap:** Limited enterprise CI/CD experience
## Important Gaps (appear in 2 jobs)
### Cloud-native architecture
- **Appears in:** Jobs 2, 3
- **Current best match:** 52% confidence
### Cross-functional team leadership
- **Appears in:** Jobs 1, 2
- **Current best match:** 67% confidence (not a gap, but could improve)
## Job-Specific Gaps
### Azure-specific experience
- **Appears in:** Job 1 only
- **Current best match:** 40% confidence
### GCP experience
- **Appears in:** Job 2 only
- **Current best match:** 35% confidence
## Aggregate Statistics
- **Total gaps:** 14
- **Unique gaps:** 8 (after deduplication)
- **Critical gaps:** 3
- **Important gaps:** 4
- **Job-specific gaps:** 1
## Recommended Discovery Time
- Critical gaps (3 gaps × 5-7 min): 15-20 minutes
- Important gaps (4 gaps × 3-5 min): 12-20 minutes
- Job-specific gaps (1 gap × 2-3 min): 2-3 minutes
**Total estimated discovery time:** 30-40 minutes
For 3 similar jobs, this replaces 3 × 15 min = 45 min of sequential discovery.1.5 Update Batch State:
{
"current_phase": "gap_analysis",
"aggregate_gaps": {
"critical_gaps": [
{
"gap_name": "Kubernetes at scale",
"appears_in_jobs": ["job-1", "job-2", "job-3"],
"current_best_match": 45,
"priority": 3
}
],
"important_gaps": [...],
"job_specific_gaps": [...]
}
}Output to User:
"Gap analysis complete! Here's what I found:
COVERAGE SUMMARY:
- Job 1 (Microsoft): 68% coverage, 5 gaps
- Job 2 (Google): 72% coverage, 4 gaps
- Job 3 (AWS): 65% coverage, 6 gaps
AGGREGATE GAPS (14 total, 8 unique after deduplication):
- 3 critical gaps (appear in all jobs) 🔴
- 4 important gaps (appear in 2 jobs) 🟡
- 1 job-specific gap 🔵
I recommend a 30-40 minute experience discovery session to address
these gaps. This will benefit all 3 applications.
Would you like to:
1. START DISCOVERY - Address gaps through conversational discovery
2. SKIP DISCOVERY - Proceed with current library (not recommended)
3. REVIEW GAPS - See detailed gap analysis first
Recommendation: Option 1 or 3 (review then start)"
Checkpoint: User chooses next action before proceeding.
Goal: Surface undocumented experiences across all gaps through single conversational session
Core Principle: Same branching interview from branching-questions.md, but with multi-job context for each question.
Session Flow:
2.1 Start with Highest-Leverage Gaps:
Process gaps in priority order:
- Critical gaps (appear in 3+ jobs) - 5-7 min each
- Important gaps (appear in 2 jobs) - 3-5 min each
- Job-specific gaps - 2-3 min each
2.2 Multi-Job Contextualized Questions:
For each gap, provide multi-job context before branching interview:
Single-Job Version (from branching-questions.md):
"I noticed the job requires Kubernetes experience. Have you worked with Kubernetes?"
Multi-Job Version (new):
"Kubernetes experience appears in 3 of your target jobs (Microsoft, Google, AWS).
This is a HIGH-LEVERAGE gap - addressing it helps multiple applications.
Current best match: 45% confidence ('Deployed containerized app for nonprofit')
Have you worked with Kubernetes or container orchestration?"
2.3 Conduct Branching Interview:
For each gap:
-
Initial probe with multi-job context (see above)
-
Branch based on answer using branching-questions.md patterns:
- YES → 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:
- "What," "how," "why" questions
- Quantify: "Any metrics?"
- Contextualize: "Was this production?"
- Validate: "This addresses {gap} for {jobs}"
-
Capture immediately with job tags:
2.4 Capture Structure:
As experiences are discovered, capture to _discovered_experiences.md:
# Discovered Experiences
**Batch:** batch-2025-11-04-job-search
**Discovery Date:** 2025-11-04T11:30:00Z
## Experience 1: Kubernetes CI/CD for nonprofit project
**Context:** Side project, 2023-2024, production deployment
**Scope:**
- GitHub Actions pipeline with Kubernetes deployments
- 3 nonprofit organizations using it
- Integrated pytest for testing
- Managed scaling and monitoring
**Metrics:**
- 3 production deployments
- 99.9% uptime over 12 months
- Reduced deployment time from 2 hours to 15 minutes
**Addresses gaps in:**
- Jobs 1, 2, 3: Kubernetes at scale
- Jobs 1, 2: CI/CD pipeline management
**Confidence Improvement:**
- Kubernetes: 45% → 75% (+30%)
- CI/CD: 58% → 82% (+24%)
**Bullet Draft:**
"Designed and implemented Kubernetes-based CI/CD pipeline using GitHub Actions
and pytest, supporting production deployments for 3 nonprofit organizations with
99.9% uptime and 87% reduction in deployment time"
**Integration Decision:** [Pending user approval]
---
## Experience 2: Azure migration for university lab
**Context:** Graduate research, 2022-2023
**Scope:**
- Migrated on-premise compute to Azure VMs
- Set up Azure DevOps for lab
- Managed costs and resource allocation
**Metrics:**
- Migrated 15 TB of data
- Reduced compute costs by 40%
- Supported 25 researchers
**Addresses gaps in:**
- Job 1 only: Azure-specific experience
**Confidence Improvement:**
- Azure: 40% → 70% (+30%)
**Bullet Draft:**
"Led Azure cloud migration for university research lab, migrating 15 TB of data
and implementing Azure DevOps, reducing compute costs by 40% while supporting
25 researchers"
**Integration Decision:** [Pending user approval]2.5 Track Coverage Improvement in Real-Time:
After each discovery, update user:
"Great! That addresses Kubernetes for all 3 jobs.
UPDATED COVERAGE:
- Job 1 (Microsoft): 68% → 78% (+10%)
- Job 2 (Google): 72% → 82% (+10%)
- Job 3 (AWS): 65% → 75% (+10%)
Remaining critical gaps: 2 (down from 3)
Continue with next gap? (Y/N)"
2.6 Integration Decision Per Experience:
After discovery session complete:
"Excellent! I captured 5 new experiences addressing gaps across your jobs.
For each experience, how should I integrate it?
---
EXPERIENCE 1: Kubernetes CI/CD for nonprofit project
├─ Addresses: Jobs 1, 2, 3
└─ Options:
1. ADD TO LIBRARY FOR ALL JOBS - Integrate and use everywhere
2. ADD TO LIBRARY, USE SELECTIVELY - User picks which jobs
3. SKIP - Don't integrate
Your choice for Experience 1? (1/2/3)
---
EXPERIENCE 2: Azure migration for university lab
├─ Addresses: Job 1 only
└─ Options:
1. ADD TO LIBRARY - Integrate for Job 1
2. SKIP - Not needed
Your choice for Experience 2? (1/2)
2.7 Enrich Library:
For each approved experience:
- Add to library database
- Tag with metadata:
- discovered_date
- addressed_gaps
- used_in_jobs
- confidence_improvement
2.8 Update Batch State:
{
"current_phase": "discovery",
"discoveries": [
{
"experience_id": "disc-1",
"text": "Kubernetes CI/CD for nonprofit project",
"context": "Side project, 2023-2024, production",
"scope": "GitHub Actions, 3 nonprofits, pytest, monitoring",
"addresses_jobs": ["job-1", "job-2", "job-3"],
"addresses_gaps": ["Kubernetes", "CI/CD"],
"confidence_improvement": {
"Kubernetes": {"before": 45, "after": 75},
"CI/CD": {"before": 58, "after": 82}
},
"integrated": true,
"bullet_draft": "Designed and implemented..."
}
]
}Output:
"Discovery complete!
SUMMARY:
- New experiences captured: 5
- Experiences integrated: 5
- Average coverage improvement: +16%
FINAL COVERAGE:
- Job 1 (Microsoft): 68% → 85% (+17%)
- Job 2 (Google): 72% → 88% (+16%)
- Job 3 (AWS): 65% → 78% (+13%)
Remaining gaps: 5 (down from 14)
├─ 0 critical gaps ✓
├─ 2 important gaps
└─ 3 job-specific gaps
Ready to proceed with per-job processing? (Y/N)"
Checkpoint: User approves before moving to per-job processing.
Goal: Process each job independently through research/template/matching/generation
Key Insight: Once discovery is complete, each job can be processed independently using enriched library.
Processing Modes:
Before starting, ask user:
"Discovery complete! Now processing each job individually.
PROCESSING MODE:
1. INTERACTIVE (default) - I'll show you checkpoints for each job
(template approval, content mapping approval)
2. EXPRESS - I'll auto-approve templates and matching using best judgment,
you review all final resumes together
Recommendation: INTERACTIVE for first 1-2 jobs, then switch to EXPRESS
if you like the pattern.
Which mode for Job 1? (1/2)"
3.1 Per-Job Loop:
For each job in batch (job.status == "pending"):
- Set job.status = "in_progress"
- Set job.current_phase = "research"
- Create job directory:
resumes/batches/{batch_id}/job-{N}-{company-slug}/ - Process through phases (see below)
- Set job.status = "completed"
- Set job.files_generated = true
- Move to next job
3.2 Phase 3A: Research (Per-Job)
Same depth as single-job workflow (SKILL.md Phase 1):
Job {N}/{total}: {Company} - {Role}
├─ Company research via WebSearch (mission, values, culture, news)
├─ Role benchmarking via LinkedIn (find 3-5 similar role holders)
├─ Success profile synthesis
└─ Checkpoint (if INTERACTIVE mode): Present success profile to user
Save to: job-{N}-{company-slug}/success_profile.md
INTERACTIVE Mode:
"Job 1: Microsoft - Principal PM
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?
(Y to proceed / provide feedback)"
EXPRESS Mode:
- Generate success profile
- Save to file
- Proceed automatically (no checkpoint)
3.3 Phase 3B: Template Generation (Per-Job)
Same process as single-job workflow (SKILL.md Phase 2):
├─ Role consolidation decisions
├─ Title reframing options
├─ Bullet allocation
└─ Checkpoint (if INTERACTIVE): Approve template structure
Save to: job-{N}-{company-slug}/template.md
INTERACTIVE Mode:
"Here's the optimized resume structure for {Company} - {Role}:
STRUCTURE:
{Section order and rationale}
ROLE CONSOLIDATION:
{Decisions with options}
TITLE REFRAMING:
{Proposed titles with alternatives}
BULLET ALLOCATION:
{Allocation with rationale}
Approve? (Y/N/adjust)"
EXPRESS Mode:
- Generate template using best judgment
- Save to file
- Proceed automatically
3.4 Phase 3C: Content Matching (Per-Job)
Same process as single-job workflow (SKILL.md Phase 3):
Uses enriched library (includes discovered experiences from Phase 2)
├─ Match content to template slots
├─ Confidence scoring (Direct/Transferable/Adjacent)
├─ Reframing suggestions
├─ Gap identification (should be minimal after discovery)
└─ Checkpoint (if INTERACTIVE): Approve content mapping
Save to: job-{N}-{company-slug}/content_mapping.md
INTERACTIVE Mode:
"Content matched for {Company} - {Role}:
COVERAGE SUMMARY:
- Direct matches: {N} bullets ({%}%)
- Transferable: {N} bullets ({%}%)
- Adjacent: {N} bullets ({%}%)
- Gaps: {N} ({%}%)
OVERALL JD COVERAGE: {%}%
[Show detailed mapping]
Approve? (Y/N/adjust)"
EXPRESS Mode:
- Generate mapping automatically
- Use highest confidence matches
- Save to file
- Proceed automatically
3.5 Phase 3D: Generation (Per-Job)
Same process as single-job workflow (SKILL.md Phase 4):
├─ Generate Markdown resume
├─ Generate DOCX resume (using document-skills:docx)
├─ Generate Report
└─ No checkpoint - just generate files
Output files:
{Name}_{Company}_{Role}_Resume.md{Name}_{Company}_{Role}_Resume.docx{Name}_{Company}_{Role}_Resume_Report.md
All saved to: job-{N}-{company-slug}/
3.6 Progress Tracking:
After each job completes:
"✓ Job {N}/{total} complete: {Company} - {Role}
QUALITY METRICS:
- JD Coverage: {%}%
- Direct Matches: {%}%
- Files: ✓ MD ✓ DOCX ✓ Report
Jobs remaining: {total - N}
Estimated time: ~{N * 8} minutes
Continue to Job {N+1}? (Y/N/pause)"
3.7 Pause/Resume Support:
If user says "pause":
"Progress saved!
CURRENT STATE:
- Jobs completed: {N}
- Jobs remaining: {total - N}
- Next: Job {N+1} - {Company} - {Role}
To resume later, say 'resume batch {batch_id}' or 'continue my batch'."
Save batch state with current progress.
Goal: Present all resumes for review, handle batch-level actions, update library
4.1 Generate Batch Summary:
Create _batch_summary.md:
# Batch Summary
**Batch ID:** batch-2025-11-04-job-search
**Created:** 2025-11-04T10:30:00Z
**Completed:** 2025-11-04T14:15:00Z
**Total Time:** 3 hours 45 minutes
## Job Summaries
### Job 1: Principal PM - Microsoft 1ES
- **Status:** Completed ✓
- **Coverage:** 85%
- **Direct Matches:** 78%
- **Key Strengths:** Azure infrastructure, cross-functional leadership, CI/CD
- **Remaining Gaps:** None critical
- **Files:**
- Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume.md
- Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume.docx
- Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume_Report.md
### Job 2: Senior TPM - Google Cloud Infrastructure
- **Status:** Completed ✓
- **Coverage:** 88%
- **Direct Matches:** 72%
- **Key Strengths:** Kubernetes experience, distributed systems, technical depth
- **Remaining Gaps:** GCP-specific (low priority, addressed in summary)
- **Files:**
- Varun_Ramesh_Google_Cloud_Senior_TPM_Resume.md
- Varun_Ramesh_Google_Cloud_Senior_TPM_Resume.docx
- Varun_Ramesh_Google_Cloud_Senior_TPM_Resume_Report.md
### Job 3: Senior PM - AWS Container Services
- **Status:** Completed ✓
- **Coverage:** 78%
- **Direct Matches:** 68%
- **Key Strengths:** Container orchestration, program management, technical leadership
- **Remaining Gaps:** AWS-specific (noted in cover letter recommendations)
- **Files:**
- Varun_Ramesh_AWS_Container_Senior_PM_Resume.md
- Varun_Ramesh_AWS_Container_Senior_PM_Resume.docx
- Varun_Ramesh_AWS_Container_Senior_PM_Resume_Report.md
## Batch Statistics
### Discovery Impact
- **New experiences discovered:** 5
- **Experiences integrated:** 5
- **Average coverage improvement:** +16%
- **Time saved vs sequential:** ~15 minutes (shared discovery)
### Coverage Metrics
- **Average JD coverage:** 84%
- **Average direct matches:** 73%
- **Total files created:** 9 (3 × MD + DOCX + Report)
### Gap Resolution
- **Starting gaps:** 14 unique gaps
- **Gaps resolved through discovery:** 9
- **Remaining gaps:** 5
- 0 critical (100% critical gap resolution)
- 2 important (50% important gap resolution)
- 3 job-specific (handled in cover letters)
## Files Location
resumes/batches/batch-2025-11-04-job-search/ ├── _batch_state.json ├── _aggregate_gaps.md ├── _discovered_experiences.md ├── _batch_summary.md (this file) ├── job-1-microsoft/ │ ├── success_profile.md │ ├── template.md │ ├── content_mapping.md │ ├── Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume.md │ ├── Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume.docx │ └── Varun_Ramesh_Microsoft_1ES_Principal_PM_Resume_Report.md ├── job-2-google/ │ └── (same structure, 6 files) └── job-3-aws/ └── (same structure, 6 files)
## Recommendations
### Interview Prep
- Prepare Kubernetes stories (appears in all 3 jobs)
- Emphasize cross-functional leadership
- Practice articulating CI/CD experience with metrics
### Cover Letter Focus
- Job 1 (Microsoft): Emphasize internal Azure knowledge, 1ES mission alignment
- Job 2 (Google): Address GCP learning plan, highlight distributed systems thinking
- Job 3 (AWS): Address AWS learning plan, emphasize container orchestration transferability
### Application Priority
Based on coverage scores and fit:
1. **Job 2 (Google):** Highest coverage (88%), strong technical fit
2. **Job 1 (Microsoft):** Strong coverage (85%), internal opportunity
3. **Job 3 (AWS):** Good coverage (78%), but more gaps to address in materials
4.2 Present to User:
"All 3 resumes generated! 🎉
JOB SUMMARIES:
┌─────────────────────────────────────────────────────────────┐
│ Job 1: Principal PM - Microsoft 1ES │
│ Coverage: 85% | Direct: 78% | Files: ✓ MD ✓ DOCX ✓ Report │
│ Key strengths: Azure infra, cross-functional leadership │
│ Remaining gaps: None critical │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ Job 2: Senior TPM - Google Cloud Infrastructure │
│ Coverage: 88% | Direct: 72% | Files: ✓ MD ✓ DOCX ✓ Report │
│ Key strengths: Kubernetes, distributed systems │
│ Remaining gaps: GCP-specific (low priority) │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│ Job 3: Senior PM - AWS Container Services │
│ Coverage: 78% | Direct: 68% | Files: ✓ MD ✓ DOCX ✓ Report │
│ Key strengths: Container orchestration, program mgmt │
│ Remaining gaps: AWS-specific (cover letter) │
└─────────────────────────────────────────────────────────────┘
BATCH STATISTICS:
- New experiences discovered: 5
- Average coverage improvement: +16%
- Total files: 9 (3 jobs × MD + DOCX + Report)
- Time saved vs sequential: ~15 minutes
FILES: resumes/batches/batch-2025-11-04-job-search/
REVIEW OPTIONS:
1. APPROVE ALL - Save all resumes to library
2. REVIEW INDIVIDUALLY - Approve/revise each resume separately
3. REVISE BATCH - Make changes across multiple resumes
4. SAVE BUT DON'T UPDATE LIBRARY - Keep files, don't enrich library
Which option? (1/2/3/4)"
4.3 Handle Review Option 1 (APPROVE ALL):
User chooses: 1
Process:
1. Copy all resume files to library directory
2. Add all discovered experiences to library database
3. Tag with metadata (batch_id, target_company, target_role, etc.)
4. Rebuild library indices
5. Update batch state to "completed"
Output:
"✓ All resumes saved to library!
LIBRARY UPDATED:
- New resumes: 3
- New experiences: 5
- Total resumes in library: 32
These experiences are now available for future applications.
Good luck with your applications! 🚀"
4.4 Handle Review Option 2 (REVIEW INDIVIDUALLY):
User chooses: 2
For each job:
Show JD requirements vs resume coverage
Highlight newly discovered experiences used
Ask: "Approve Job {N}? (Y/N/revise)"
If Y: Add to library
If N: Don't add to library
If revise: Collect feedback, make changes, re-ask
After all reviewed:
"Review complete!
LIBRARY UPDATED:
- Approved resumes: {N}
- Skipped resumes: {M}
- Revised resumes: {K}
Total resumes in library: {count}"
4.5 Handle Review Option 3 (REVISE BATCH):
User chooses: 3
Prompt:
"What would you like to change across the batch?
COMMON BATCH REVISIONS:
- 'Make all summaries shorter'
- 'Emphasize leadership more in all resumes'
- 'Remove mentions of X technology from all'
- 'Use title \"Senior Technical Program Manager\" consistently'
- 'Add bullets about Y experience to all resumes'
Your revision request:"
Process:
1. Collect revision request
2. Determine which jobs affected
3. Re-run matching/generation for affected jobs
4. Present revised resumes
5. Ask for approval again
Loop until user approves or cancels.
4.6 Handle Review Option 4 (SAVE BUT DON'T UPDATE LIBRARY):
User chooses: 4
Output:
"✓ Files saved to: resumes/batches/batch-2025-11-04-job-search/
Not added to library. You can manually move them later if desired.
Batch state preserved for future reference."
4.7 Update Final Batch State:
{
"batch_id": "batch-2025-11-04-job-search",
"current_phase": "completed",
"completed_at": "2025-11-04T14:15:00Z",
"jobs": [
{
"job_id": "job-1",
"status": "completed",
"files_generated": true,
"added_to_library": true
}
],
"statistics": {
"total_jobs": 3,
"completed_jobs": 3,
"new_experiences": 5,
"average_coverage": 84,
"total_time_minutes": 225
}
}Goal: Add new jobs to existing batches without re-doing completed work
Scenario: User processes 3 jobs today, finds 2 more jobs next week
8.1 Detect Add Request:
User says:
- "Add another job to my batch"
- "I found 2 more jobs"
- "Resume batch {batch_id} and add jobs"
8.2 Load Existing Batch:
# Pseudo-code
batch = load_batch_state(batch_id)
if batch.current_phase == "completed":
print("Batch already completed. Creating extension...")
batch.current_phase = "intake" # Reopen for new jobs8.3 Intake New Jobs:
Same process as Phase 0, but:
- Append to existing batch.jobs list
- Assign new job_ids (continue numbering: job-4, job-5, etc.)
"Adding jobs to existing batch: {batch_id}
CURRENT BATCH:
- Job 1: Microsoft - Principal PM (completed ✓)
- Job 2: Google - Senior TPM (completed ✓)
- Job 3: AWS - Senior PM (completed ✓)
NEW JOBS TO ADD:
Provide job description for Job 4: [user input]
[... collect JD, company, role, priority, notes ...]
Add another job? (Y/N)
8.4 Incremental Gap Analysis:
"Running incremental gap analysis for new jobs...
NEW JOBS:
- Job 4 (Stripe): Payment Systems Engineer
- Job 5 (Meta): Senior TPM
COVERAGE WITH EXISTING LIBRARY:
(Library now includes 5 experiences discovered in previous session)
- Job 4 (Stripe): 82% coverage
- Job 5 (Meta): 75% coverage
NEW GAPS (not covered by previous discoveries):
- Payment systems experience (Job 4 only) 🔵
- Large-scale social networking (Job 5 only) 🔵
- React/frontend (Jobs 4, 5) 🟡
ALREADY COVERED FROM PREVIOUS BATCH:
✓ Kubernetes (from previous batch)
✓ CI/CD (from previous batch)
✓ Cross-functional leadership (from previous batch)
NEW GAP COUNT: 3 (vs 14 in original batch)
Estimated discovery time: 5-10 minutes (vs 30-40 for original batch)
Ready for incremental discovery? (Y/N)"
8.5 Incremental Discovery:
Only ask about NEW gaps:
# Pseudo-code
previous_gaps = set(batch.aggregate_gaps.all_gap_names())
new_gaps = []
for job in new_jobs:
for gap in job.gaps:
if gap.name not in previous_gaps:
new_gaps.append(gap)
# Run discovery ONLY for new_gaps
conduct_discovery(new_gaps)Important: Don't re-ask questions already answered in previous session.
8.6 Process New Jobs:
Run Phase 3 (per-job processing) for new jobs only:
- Job 4: Research → Template → Matching → Generation
- Job 5: Research → Template → Matching → Generation
8.7 Update Batch Summary:
Add new jobs to _batch_summary.md:
## Incremental Addition (2025-11-11)
Added 2 new jobs to batch after initial completion.
### Job 4: Payment Systems Engineer - Stripe
... [same format as original jobs]
### Job 5: Senior TPM - Meta
... [same format as original jobs]
## Updated Statistics
- Total jobs: 5 (original 3 + added 2)
- New experiences discovered (incremental): 3
- Total experiences discovered: 88.8 Final Output:
"Incremental batch processing complete!
ORIGINAL BATCH (2025-11-04):
✓ Job 1: Microsoft
✓ Job 2: Google
✓ Job 3: AWS
NEW JOBS (2025-11-11):
✓ Job 4: Stripe
✓ Job 5: Meta
NEW DISCOVERIES: 3
TIME SAVED: ~25 minutes (avoided re-asking 8 previous gaps)
All 5 resumes available in: resumes/batches/{batch_id}/
Add to library? (Y/N)"
Detection: During gap analysis, <40% gap overlap between jobs
Scenario: User provides 5 jobs, but they're quite different (TPM, Data Scientist, Product Marketing Manager)
Handling:
"⚠️ I notice these jobs are quite diverse:
JOB SIMILARITY ANALYSIS:
- Jobs 1, 2 (TPM roles): 85% requirement overlap ✓
- Jobs 3, 4 (Data Science): 80% requirement overlap ✓
- Job 5 (Marketing): Only 20% overlap with others ⚠️
RECOMMENDATION:
Split into batches for better efficiency:
- Batch A: Jobs 1, 2 (TPM-focused discovery)
- Batch B: Jobs 3, 4 (Data Science-focused discovery)
- Job 5: Process separately (single-job mode)
OR proceed with unified discovery (will take longer, ~50 minutes)
Your preference:
1. Split into batches (recommended)
2. Continue with unified discovery
3. Remove dissimilar jobs"
Scenario: During discovery for "multi-job gap," user's answer only addresses one job
Example:
SKILL: "Kubernetes appears in all 3 jobs. Have you worked with it?"
USER: "Only in Azure (AKS), not GCP or AWS"
HANDLING:
"Got it - this addresses the Microsoft job (Azure AKS) but not Google (GKE)
or AWS (EKS).
I'll tag this as Microsoft-specific.
Should I still explore Kubernetes more broadly? You might have experience
with container orchestration concepts that transfer across cloud providers.
Options:
1. YES - Explore general container orchestration
2. NO - Move to next gap
Your choice? (1/2)"
[If 1, branch to adjacent probe for container orchestration concepts]
Scenario: Company is obscure startup, minimal online presence
Handling:
"⚠️ Limited research data for Job 3 (StartupXYZ):
- No company website or information found
- No LinkedIn profiles for similar roles
- No news or press coverage
FALLBACK: JD-only analysis for this job
OPTIONS:
1. CONTINUE - Proceed with JD-only (recommended)
2. SKIP JOB 3 - Process others, come back later
3. PROVIDE CONTEXT - You share company info manually
4. REMOVE JOB 3 - Remove from batch entirely
Other jobs (1, 2) have sufficient research data.
Your preference? (1/2/3/4)"
[Don't let one failure block the entire batch]
Add Job Mid-Process:
USER: "I want to add another job to the batch"
SKILL: "Adding Job {N+1} to batch.
CURRENT PHASE: {current_phase}
Since we've already completed discovery:
- If Job {N+1} has NEW gaps: We'll do quick incremental discovery
- If existing discoveries cover it: Proceed directly to processing
Let me collect the job details..."
[Run quick gap check, incremental discovery if needed, then process]
Remove Job Mid-Process:
USER: "Remove Job 2 from the batch"
SKILL: "Removing Job 2 from batch.
ALREADY-DISCOVERED EXPERIENCES:
- Will remain in library
- Still available for other jobs in batch
- Available for future batches
BATCH UPDATED:
- Jobs remaining: {N-1}
- Job 2 files will be moved to archive (not deleted)
Continue with remaining jobs? (Y/N)"
Scenario: User approves Job 1 resume, rejects Job 2, wants to revise Job 3
Handling:
"You've approved some jobs but not others.
LIBRARY UPDATE OPTIONS:
1. INDIVIDUAL APPROVAL (recommended)
- Add Job 1 to library now ✓
- Job 2 won't be added ✗
- Job 3 pending revision (decide after changes)
2. BATCH APPROVAL (wait)
- Update library only when all jobs finalized
- Ensures consistency across batch
3. SELECTIVE APPROVAL
- Choose which jobs to add now
- Which experiences to integrate
Recommendation: Option 1 (individual approval)
Your preference? (1/2/3)"
Scenario: User stops mid-batch, connection drops, or session ends
Auto-Save Behavior:
After each major milestone, auto-save batch state:
- After each job completes
- After discovery phase
- After gap analysis
- After user checkpoints
Resume Instructions:
"Your batch processing was interrupted.
SAVED STATE:
- Batch ID: {batch_id}
- Completed: Jobs 1, 2
- In Progress: Job 3 (template approved, matching not started)
- Pending: Jobs 4, 5
To resume:
- Say 'resume batch {batch_id}'
- Or 'continue my batch'
- Or provide batch ID when asked
I'll pick up exactly where we left off."
Scenario: All jobs are well-covered by existing library (rare but possible)
Handling:
"Gap analysis complete!
COVERAGE SUMMARY:
- Job 1: 92% coverage
- Job 2: 89% coverage
- Job 3: 87% coverage
ALL GAPS ADDRESSABLE WITH EXISTING LIBRARY ✓
No experience discovery needed - your library already covers these roles well.
OPTIONS:
1. SKIP DISCOVERY - Proceed directly to per-job processing (recommended)
2. OPTIONAL DISCOVERY - Surface any additional experiences anyway
3. REVIEW GAPS - See what small gaps exist
Your preference? (1/2/3)"
- Never lose progress: Auto-save batch state frequently
- Partial success is success: Some jobs completing is better than none
- Transparent failures: Always explain what went wrong and options
- Graceful degradation: Fall back to JD-only, single-job mode, or skip if needed
- User control: Always provide options, never force a path
Research fails → Fall back to JD-only analysis
Library too small → Emphasize discovery phase
WebSearch unavailable → Use cached data or skip research
DOCX generation fails → Provide markdown only
One job fails → Continue with others, revisit failed job later