Cv Creator

CV Creator

Professional resume builder that transforms structured career data into ATS-optimized, professionally formatted resumes.

Integrations

Works with: career-biographer, competitive-cartographer, web-design-expert, typography-expert

Production Implementation Available!

GitHub: github.com/erichowens/cv-creator

• Status: Production-ready (~2,000 LOC)
• ATS Score: 95/100 achieved
• Deploy: npm install && npm run example

Built through multi-skill orchestration (8 skills, 9 phases).

Quick Start

User: "Create a resume for senior software engineer roles"

CV Creator:
1. Request CareerProfile (from biographer or direct input)
2. Request PositioningStrategy (from cartographer or skip)
3. Request target role/company (optional)
4. Generate resume with clean formatting
5. Calculate ATS score and provide recommendations
6. Export in requested formats (PDF, DOCX, JSON Resume)

Key principle: ATS compatibility first, human readability second, visual flair never.

Core Capabilities

1. Multi-Format Generation

2. ATS Optimization Engine

• Keyword analysis and matching from job descriptions
• Formatting validation (single-column, standard fonts)
• Scoring system (0-100) with specific recommendations
• Parsing simulation

3. Template System

ATS Score Breakdown

Target: 85+ out of 100

When to Use

Use for:

• Creating resume from career-biographer data
• Optimizing resume for specific job posting
• Generating multiple resume variants
• ATS score and improvement recommendations
• Multi-format export

Do NOT use for:

• Cover letters (different format)
• Portfolio websites (use web-design-expert)
• LinkedIn profile optimization
• Interview preparation
• Career counseling or job search strategy

Anti-Patterns

Anti-Pattern: Creative Resume for Tech Roles

What it looks like: Colorful infographics, skill bars, profile photo, two-column layout Why wrong: ATS systems can't parse graphics or complex layouts Instead: Use Minimalist template with clean, single-column text format

Anti-Pattern: Generic Objective Statement

What it looks like: "Seeking a challenging role in a growth-oriented company..." Why wrong: Wastes space, provides no information Instead: Professional summary with specific metrics and target role

Anti-Pattern: Listing Every Technology Ever Used

What it looks like: 40+ skills including outdated technologies Why wrong: Dilutes expertise, unclear proficiency Instead: List 15-20 most relevant skills for target role

Anti-Pattern: Responsibilities Without Outcomes

What it looks like: "Managed a team", "Worked on backend systems" Why wrong: Doesn't show impact or value Instead: "Led team of 5 to deliver microservices migration, reducing deployment time by 70%"

Anti-Pattern: Inconsistent Formatting

What it looks like: Mixed date formats, different bullet styles, varying fonts Why wrong: Looks unprofessional, confuses ATS parsers Instead: Strict consistency throughout

Troubleshooting Quick Reference

Length Guidelines

Never exceed 2 pages, even for very senior roles.

Reference Files

• references/resume-protocol.md - Complete 8-step generation protocol, ATS scoring, before/after examples
• references/formatting-rules.md - Best practices, templates, output formats, success metrics
• references/interfaces-integration.md - TypeScript interfaces, multi-skill workflows

---

Core insight: ATS compatibility first—the best-written resume is worthless if it never reaches human eyes.

Use with: career-biographer (content) | competitive-cartographer (positioning) | web-design-expert (portfolio)

Changelog

[2.0.0] - 2024-01-XX

Changed

• BREAKING: Restructured from monolithic 691-line file to progressive disclosure architecture
• Fixed frontmatter format: tools: → allowed-tools: (comma-separated)
• Added NOT clause to description for precise activation boundaries
• Reduced SKILL.md from 691 lines to 153 lines (78% reduction)

Added

• references/resume-protocol.md - 8-step generation protocol, ATS scoring breakdown
• references/formatting-rules.md - Best practices, templates, output formats
• references/interfaces-integration.md - TypeScript interfaces, three-skill workflow
• Anti-patterns section with "What it looks like / Why wrong / Instead" format
• ATS scoring quick reference (30/20/30/20 breakdown)
• Template system documentation (Minimalist, Traditional, Creative, Academic)

Removed

• Inline TypeScript interfaces (moved to references)
• Verbose resume examples (condensed to key patterns)
• Redundant formatting rules

Migration Guide

Reference files are now in /references/ directory. Import patterns:

• Generation protocol → references/resume-protocol.md
• Template system → references/formatting-rules.md
• TypeScript types → references/interfaces-integration.md

Formatting Rules & Best Practices

Complete formatting guidelines, templates, and output format specifications.

Formatting Rules

Do:

• ✓ Use standard fonts (Calibri, Arial, Georgia, Times New Roman)
• ✓ Font size 10-12pt for body, 14-16pt for headers
• ✓ Single-column layout (no tables, no text boxes)
• ✓ Standard section headers ("Work Experience", not "My Journey")
• ✓ Consistent date format (MM/YYYY or Month YYYY)
• ✓ Plain bullet points (•, -, or standard symbols)
• ✓ Margins 0.5-1 inch

Don't:

• ✗ Use graphics, images, logos, or headshots
• ✗ Include headers/footers (info can be lost in ATS)
• ✗ Use tables or columns
• ✗ Add special characters or emojis
• ✗ Use creative section names
• ✗ Include personal information (age, marital status, photo)

Length Guidelines

Never exceed 2 pages, even for very senior roles.

Content Best Practices

1. Lead with Impact, Not Responsibilities

❌ "Responsible for maintaining database infrastructure" ✓ "Optimized database queries and indexing strategy, reducing query latency by 60% and infrastructure costs by $50K annually"

2. Use Specific Metrics

❌ "Improved system performance" ✓ "Reduced API response time from 500ms to 200ms (60% improvement)"

3. Show Career Progression

❌ Listing same responsibilities for each role ✓ Each role shows increased scope, leadership, or technical complexity

4. Tailor for Each Application

• Reorder skills to match job description priority
• Emphasize relevant experience in recent roles
• Adjust professional summary for target company

Template System

Modern Minimalist (Default - Best for Tech)

• Clean sans-serif typography (Calibri, Tahoma, Arial)
• Single-column layout with generous whitespace
• Clear visual hierarchy
• Ideal for: Software Engineers, Data Scientists, Product Managers

Professional Traditional (Conservative Industries)

• Serif typography (Georgia, Times New Roman)
• Formal, structured layout
• Conservative color palette
• Ideal for: Finance, Legal, Senior Executives, Academia

Creative Hybrid (Design-Forward Tech)

• Modern sans-serif with subtle accent color (1-2 colors max)
• Balanced visual interest with ATS compatibility
• Clean but distinctive
• Ideal for: Design Engineers, UX Researchers, Creative Technologists

Academic CV (Research & Academia)

• LaTeX-based professional formatting
• Publications, citations, research sections
• Multi-page support
• Ideal for: PhD Candidates, Professors, Research Scientists

Output Formats

PDF Resume

Characteristics:

• Print-ready, professional appearance
• ATS-compatible single-column layout
• Standard fonts for universal compatibility

Use cases: Email applications, job boards, print for interviews

DOCX Resume

Characteristics:

• Editable in Microsoft Word, Google Docs, LibreOffice
• Preserves formatting with proper styles
• Allows recruiters to make notes/edits

Use cases: Recruiter submissions, applications requiring Word format

JSON Resume

Characteristics:

• Structured data following jsonresume.org schema
• Version-controllable with git
• Programmatically parseable

Use cases: Developer portfolios, personal websites, automated generation

HTML Resume

Characteristics:

• Responsive web design
• Print stylesheet for PDF generation
• Semantic HTML for accessibility

Use cases: Portfolio websites, GitHub Pages, email signatures

Markdown Resume

Characteristics:

• Plain text, human-readable
• Version control friendly
• Convertible via Pandoc

Use cases: Source of truth, git-based management, rapid iteration

Success Metrics

A well-generated resume should achieve:

Interfaces & Integration Workflows

TypeScript interfaces and multi-skill integration patterns.

CareerProfile Interface (from career-biographer)

interface CareerProfile {
  // Identity
  name: string;
  headline: string;
  summary: string;

  // Timeline
  timelineEvents: Array<{
    date: string;
    type: 'role_change' | 'patent' | 'award' | 'publication' | 'milestone';
    title: string;
    description: string;
    impact: string;
    tags: string[];
  }>;

  // Skills
  skills: Array<{
    category: 'technical' | 'leadership' | 'domain' | 'soft';
    name: string;
    proficiency: number; // 0-100
    yearsOfExperience: number;
  }>;

  // Projects
  projects: Array<{
    name: string;
    role: string;
    description: string;
    technologies: string[];
    impact: string;
    metrics: string[];
  }>;
}

PositioningStrategy Interface (from competitive-cartographer)

interface PositioningStrategy {
  positioning: {
    headline: string;
    differentiators: string[];
    messaging: string;
  };

  contentStrategy: {
    tone: string;
    depth: string;
  };
}

Three-Skill Orchestrated Workflow

User: "I need a resume for FAANG senior backend engineer roles"

Step 1: career-biographer
→ Conducts empathetic interview
→ Extracts structured CareerProfile
→ Documents achievements, skills, timeline

Step 2: competitive-cartographer
→ Maps FAANG senior backend landscape
→ Identifies white space and differentiators
→ Generates PositioningStrategy

Step 3: cv-creator
→ Combines CareerProfile + PositioningStrategy
→ Generates ATS-optimized resume
→ Tailors for FAANG technical expectations
→ Outputs multi-format files

Deliverables:
- resume-faang-senior-backend.pdf
- resume-faang-senior-backend.docx
- resume-faang-senior-backend.json
- ats-analysis-faang-senior-backend.md

Standalone Quick Optimization

User: "Optimize my resume for this job posting: [URL]"

cv-creator:
1. Fetch job description from URL
2. Extract required keywords and skills
3. Load existing resume (or request CareerProfile)
4. Reorder and emphasize relevant experience
5. Add missing keywords to Core Skills
6. Generate optimized variant
7. Calculate new ATS score
8. Provide recommendations

Output:
- resume-optimized-company-role.pdf
- ATS Score: 89/100 (↑12 points)
- Keyword Coverage: 85% (↑20%)

Integration Partners

Production Implementation

GitHub: github.com/erichowens/cv-creator

• Status: Production-ready (~2,000 LOC)
• ATS Score: 95/100 achieved
• Deploy: npm install && npm run example

Built through multi-skill orchestration (8 skills, 9 phases):

• ATS-optimized PDF resumes (<5 sec)
• Deploy-ready portfolio websites (<1 sec)
• Detailed validation reports

Resume Generation Protocol

Complete 8-step protocol for generating ATS-optimized resumes.

Step 1: Gather Inputs

Required:

• CareerProfile (from biographer or user-provided JSON)

Optional but recommended:

• PositioningStrategy (from cartographer)
• Target Role (e.g., "Senior Backend Engineer")
• Target Company (e.g., "Google")
• Job Description URL or text (for keyword optimization)

Step 2: Generate Professional Summary

Transform career data into a compelling 2-4 line summary:

Formula:

[Seniority Level] + [Technical Focus] with [Years] years building [Domain].
[Key Achievement with Metric]. Expertise in [Top 3-5 Skills].
[Current Goal or Target Role].

Example:

Senior Backend Engineer with 8 years building scalable distributed systems.
Led microservices migration serving 10M+ users with 40% latency reduction.
Expertise in Go, Kubernetes, gRPC, and cloud-native architecture.
Seeking principal engineering role focused on infrastructure optimization.

Avoid:

• Generic buzzwords ("passionate", "results-oriented")
• Objective statements ("Seeking a challenging role...")
• Listing achievements (save for Work Experience)

Step 3: Create Core Skills Section

Select and prioritize 15-20 technical skills:

Prioritization criteria: 1. Mentioned in job description (if provided) 2. Highest proficiency level from CareerProfile 3. Most years of experience 4. Relevant to target role

Format:

Core Skills:
Go, Kubernetes, Docker, gRPC, PostgreSQL, Redis, Microservices Architecture,
Distributed Systems, AWS, Terraform, CI/CD, System Design, API Design,
Performance Optimization, Monitoring & Observability

Avoid:

• Generic skills ("Problem Solving", "Team Player")
• Too many skills (>25 overwhelming, <10 insufficient)
• Listing skills not mentioned elsewhere in resume

Step 4: Format Work Experience

Transform timeline events into results-oriented bullet points:

Bullet point formula:

[Action Verb] + [What you did] + [How/Why you did it] + [Quantifiable Result]

Examples:

✓ Led microservices migration from monolith architecture, reducing API latency by 40% and improving deployment frequency from weekly to daily releases

✓ Architected event-driven system handling 10M+ daily active users using Kubernetes, Go, and gRPC with 99.99% uptime SLA

✓ Mentored team of 5 junior engineers through code reviews and pair programming, resulting in 50% faster onboarding time

Common action verbs:

• Leadership: Led, Managed, Directed, Coordinated, Mentored
• Technical: Architected, Built, Designed, Implemented, Optimized
• Impact: Reduced, Increased, Improved, Accelerated, Scaled
• Innovation: Pioneered, Created, Launched, Introduced, Developed

Avoid:

• Starting with "Responsible for..." or "Duties included..."
• Listing technologies without context
• Vague metrics ("significantly improved", "greatly reduced")
• Bullets longer than 2 lines

Step 5: Format Education

Keep education section concise:

Format:

Bachelor of Science in Computer Science
University of California, Berkeley | 2015

Master of Science in Distributed Systems
Stanford University | 2017

When to include GPA:

• Recent graduate (<5 years) AND GPA ≥3.5
• Otherwise, omit

Avoid:

• Listing coursework (unless first job)
• Including high school education
• Redundant location info

Step 6: Apply Template Styling

Select appropriate template based on:

• Target industry (tech = Minimalist, finance = Traditional)
• Career stage (early career = cleaner, senior = more content)
• Personal brand (creative roles = Creative Hybrid)
• Academic roles = Academic CV template

Step 7: Generate ATS Analysis

Calculate ATS score based on:

Formatting Compliance (30 points):

• Single-column layout: 10 points
• Standard fonts: 10 points
• No graphics/images: 10 points

Section Structure (20 points):

• Has Professional Summary: 5 points
• Has Core Skills: 5 points
• Has Work Experience: 5 points
• Has Education: 5 points

Content Quality (30 points):

• Summary length 100-500 chars: 10 points
• Skills section 10-25 skills: 10 points
• Experience bullets have metrics: 10 points

Keyword Optimization (20 points):

• If job description provided: calculate keyword coverage
• If not: award 15 points for general optimization

Total Score: 0-100

Step 8: Provide Recommendations

Generate specific, actionable improvements:

Example output:

ATS Score: 87/100

✓ Strengths:
- Clean single-column formatting passes ATS parsing
- Professional summary is concise and role-specific
- Work experience bullets include quantifiable metrics

⚠️ Improvements:
- Add "Terraform" to Core Skills (mentioned 3x in job description)
- Increase keyword coverage from 75% to 85% by including "CI/CD pipeline"
- Consider adding certification section with "AWS Certified Solutions Architect"

Before/After Example

Before (Generic Resume)

John Doe
Software Engineer

Objective:
Seeking a challenging position in software development where I can utilize my skills.

Experience:
- Worked on various backend systems
- Developed new features
- Fixed bugs and improved code quality

Skills:
Programming, Problem Solving, Team Player, Communication

ATS Score: 45/100 Issues: Generic objective, vague bullets, no metrics, missing keywords

After (CV Creator Optimized)

John Doe | john.doe@email.com | linkedin.com/in/johndoe | github.com/johndoe

PROFESSIONAL SUMMARY
Senior Backend Engineer with 7 years building scalable microservices architectures.
Led migration to event-driven systems serving 5M+ users with 99.99% uptime. Expertise
in Go, Kubernetes, PostgreSQL, and distributed systems. Seeking principal engineering
role focused on infrastructure scalability.

CORE SKILLS
Go, Kubernetes, Docker, PostgreSQL, Redis, Microservices, Event-Driven Architecture,
gRPC, REST APIs, AWS, Terraform, CI/CD, System Design, Performance Optimization

WORK EXPERIENCE

TechCorp Inc | Senior Backend Engineer | June 2020 - Present
• Led microservices migration from monolith, reducing deployment time from 2 hours to 15 minutes
• Architected event-driven system processing 500K messages/sec with 99.99% uptime SLA
• Optimized PostgreSQL queries, reducing average query time from 800ms to 120ms (85% improvement)
• Mentored 3 junior engineers, resulting in promotion to mid-level within 12 months

EDUCATION
Bachelor of Science in Computer Science | Stanford University | 2017

ATS Score: 92/100 Improvements: Quantifiable metrics, specific technologies, clear progression, keyword-optimized