Vibe-CV-Resume: AI-Powered LaTeX CV Management

Tired of manually tweaking your CV for every job application? Discover how developers are revolutionizing resume maintenance with AI agents, LaTeX, and Git version control.

In 2025, we code with AI agents that understand context, make intelligent edits, and iterate based on feedback. Yet most professionals still wrestle with Word documents, copying bullet points, and praying their formatting doesn't break. The disconnect is staggering. Vibe-cv-resume bridges this gap by treating your CV as code—where LaTeX provides structure, Git tracks history, and AI agents handle the heavy lifting. This isn't just another resume template; it's a complete paradigm shift for developers who want to leverage the same powerful workflows they use daily for their most important career document. In this deep dive, you'll learn exactly how to set up this revolutionary system, harness AI for ATS optimization, and maintain multiple CV variants with zero manual formatting headaches.

What Is Vibe-CV-Resume?

Vibe-cv-resume is an open-source framework created by madnanrizqu that fundamentally reimagines how developers maintain their curricula vitae. At its core, it's a Git-based repository structure combining professional LaTeX templates, battle-tested AI prompts, and Docker-powered development environments to automate the entire CV lifecycle. Unlike traditional resume builders that trap you in proprietary interfaces, this approach leverages tools you already know and love: VS Code, Git, and your existing AI coding assistant subscription.

The project emerged from a simple observation—if Claude and Cursor can refactor complex codebases, why can't they optimize your resume bullet points? The repository provides three distinct LaTeX templates (gergely, gogo, and harshibar), each with unique styling philosophies, plus a sophisticated folder architecture that separates content from presentation. This separation is crucial: you can swap entire visual themes without touching a single achievement statement.

What makes vibe-cv-resume particularly trending in 2025 is its agentic approach. Rather than manually editing LaTeX files, you feed structured prompts to AI agents that understand LaTeX syntax, ATS requirements, and recruiter psychology. The system includes pre-built prompt templates for job description matching, achievement optimization, and expert CV critique. It's essentially pair-programming with AI, but for your career narrative. The framework is completely free, MIT-licensed, and designed for developers who already pay for AI coding assistants and want to maximize that investment across all structured text problems.

Key Features That Make It Revolutionary

Vibe-cv-resume packs a powerful punch with features designed for modern development workflows. First, the template abstraction layer completely decouples your content from styling. Each template folder contains a preamble.tex file defining all visual elements—fonts, colors, layouts, section styling—while your actual CV content lives separately in the v1/ directory. This means you can switch from a minimalist design to a three-column engineering style in seconds by changing a single input{...} path.

The AI prompt library is where the magic happens. The prompts/ directory includes job_desc_match.md, a sophisticated template that instructs AI agents to analyze job postings and rewrite your experience bullets for maximum ATS alignment. These prompts are engineered specifically for Claude, GPT-4, and Cursor, using techniques like few-shot examples and chain-of-thought reasoning to produce recruiter-ready content. The prompts understand LaTeX syntax, so they won't break your itemize environments or section commands.

Git-native versioning transforms CV management into a proper software engineering practice. Create feature branches for different job applications, merge the best changes back to master, and tag versions for specific submissions. The .gitignore is pre-configured to exclude compiled PDFs while tracking source .tex files, keeping your repository lean. You can run git diff to see exactly how you tailored your CV for Google versus Microsoft, creating a searchable history of what works.

The Docker dev container eliminates LaTeX installation hell. One click in VS Code and you have a complete TeX Live environment with all packages, fonts, and build tools. No more debugging pdflatex errors or hunting for missing fontawesome5 packages. The container includes latexmk for automatic compilation and PDF preview, giving you instant feedback as you iterate with your AI agent.

Finally, multi-variant management through the folder structure lets you maintain a master CV while spawning job-specific versions. Each application gets its own subdirectory containing the tailored main.tex and the original job_desc.md for reference. This creates a deterministic pipeline: job description → AI optimization → compiled PDF → git commit, all traceable and reproducible.

Real-World Use Cases Where It Shines

Scenario 1: The ATS Optimization Sprint You've found your dream job at a fintech startup. Their posting emphasizes "distributed systems," "Kafka," and "event-driven architecture." Instead of manually scanning your CV and guessing which bullets to rewrite, you copy the job description into v1/fintech_startup/job_desc.md and run the AI prompt. In 30 seconds, your agent transforms "Worked on messaging systems" into "Designed event-driven architecture using Kafka, processing 10M+ daily transactions with 99.99% reliability." The agent automatically quantifies achievements and injects exact keywords, boosting your ATS score while maintaining truthfulness.

Scenario 2: The Template A/B Test You're applying to both traditional enterprises and edgy startups. Enterprise recruiters expect conservative layouts; startups appreciate modern design. With vibe-cv-resume, you maintain one content source in v1/master.tex but compile it against different templates. Branch enterprise uses the harshibar minimal template, while branch startup uses gergely's three-column style. Git merge lets you propagate content updates across both variants, and you can even run git diff branch1 branch2 -- v1/master.tex to verify content parity.

Scenario 3: The Achievement Refactoring Marathon Your CV bullets are weak: "Responsible for improving system performance." You know they're bad, but rewriting is mentally draining. You paste the entire v1/master.tex into Cursor with the optimization prompt and watch the agent apply the STAR method (Situation, Task, Action, Result) to every bullet. "Responsible for improving system performance" becomes "Reduced API latency by 78% (from 850ms to 190ms) by implementing Redis caching and query optimization, serving 500K+ daily users." The agent adds metrics, action verbs, and impact statements automatically.

Scenario 4: The Version Control Safety Net You tailored your CV for a role, got rejected, but want to reuse some of those improved bullets for a new application. Without version control, those refinements are lost in a sea of .docx files. With vibe-cv-resume, you simply git checkout -b new_application from the rejected branch, cherry-pick the best commits, and discard the rest. Your Git history becomes a searchable database of every CV iteration, showing which phrasings got you interviews versus rejections.

Scenario 5: The Collaborative Review Your senior developer friend offers to review your CV. Instead of emailing PDFs with "track changes" comments, you push your branch to GitHub and open a pull request. They leave line-by-line suggestions on your LaTeX source. You can accept or reject each suggestion, creating a permanent record of the review. The AI agent can even incorporate this feedback automatically, learning your mentor's preferences for future optimizations.

Step-by-Step Installation & Setup Guide

Prerequisites Checklist

Before diving in, ensure you have:

• VS Code installed (the framework is optimized for it)
• A GitHub account for version control and forking
• Docker Desktop (for the dev container approach) OR willingness to install TeX Live manually
• An AI coding assistant subscription (Claude, Cursor, or GPT-4)

Method 1: Docker Dev Container (Recommended)

This approach gives you a bulletproof LaTeX environment in under 5 minutes:

1. Install Docker Desktop from docker.com/products/docker-desktop
2. Add the Dev Containers extension to VS Code from the marketplace
3. Fork and clone the repository:

   git clone https://github.com/YOUR_USERNAME/vibe-cv-resume.git
   cd vibe-cv-resume
   code .
   

4. Open in container: When VS Code detects the .devcontainer/ folder, it will prompt "Reopen in Container." Click it.
5. Wait for initialization: The container builds automatically, installing TeX Live and all dependencies. This takes 2-3 minutes on first run.
6. Verify the setup: Open the terminal inside VS Code (which is now running in the container) and type:

   latexmk -pdf templates/harshibar/master.tex
   

   You should see a clean compilation and a master.pdf appear.

Method 2: Manual Installation (Mac ARM)

If you prefer native installation or need custom TeX packages:

1. Install MacTeX:

   brew install --cask mactex-no-gui
   

   This installs the full TeX Live distribution without the GUI applications, saving disk space.

2. Configure your PATH: TeX Live installs to a versioned directory. Add it to your shell profile:

   # For bash/zsh users
   eval "$(/usr/libexec/path_helper)"
   
   # Or manually add (replace YYYY with your version year)
   export PATH="/usr/local/texlive/YYYY/bin/universal-darwin:$PATH"
   

3. Install the LaTeX Workshop extension in VS Code for live preview and compilation shortcuts.

4. Test your installation:

   latexmk -pdf templates/gergely/master.tex
   

5. Install additional packages if needed: The templates use common packages, but if compilation fails, use tlmgr:

   sudo tlmgr install fontawesome5 etoolbox
   

Choosing Your Template

Browse the pre-built PDFs in the repository to make an informed decision:

• gergely: Pragmatic Engineer style with a distinctive three-column header and blue section headings. Perfect for senior engineers who want to showcase multiple skill dimensions.
• gogo: Clean, corporate professional style by Listiarso Wastuargo. Ideal for management consultants, product managers, and traditional tech roles.
• harshibar: Minimal, content-first design based on Jake Yang's template. Excellent for academics, researchers, and developers who let their work speak loudly.

Initializing Your Personal CV

Once you've chosen a template, execute these commands in your terminal:

# Remove the placeholder v1 directory
rm -rf v1/

# Create your personal CV space
mkdir v1

# Copy your chosen template's content file
cp templates/gergely/master.tex v1/

# Update the preamble reference in v1/master.tex
# Change the first line from \input{preamble} to:
# \input{../templates/gergely/preamble}

Now edit v1/master.tex with your personal information. The preamble handles all styling—just focus on content.

REAL Code Examples from the Repository

Example 1: The Template Preamble Reference

This LaTeX command is the linchpin of the entire abstraction system. It lives at the top of your v1/master.tex file and tells the compiler where to find styling definitions:

% v1/master.tex - Your personal CV content file
% This line connects your content to a specific template's styling
\input{../templates/gergely/preamble}

% Everything below is pure content - no styling commands needed
\begin{document}
\name{Your Name}
\tagline{Your Professional Tagline}

% The preamble defines how these sections render
\begin{resume}
  \section{Experience}
  % Your experience items here
\end{resume}
\end{document}

How it works: The \input command is LaTeX's equivalent of a C #include or JavaScript import. It inserts the entire preamble.tex file at compilation time. The ../ path navigates up from your v1/ directory to the repository root, then into templates/gergely/. This relative path ensures your CV compiles correctly from any branch or fork. Key insight: You can switch templates instantly by changing gergely to gogo or harshibar—zero content changes required.

Example 2: Folder Structure Tree

The repository's architecture is deliberately designed to separate concerns. Here's the exact structure from the README:

├── templates/                  # CV layout templates (preamble stays here)
│   ├── gergely/                # Pragmatic Engineer style - 3-column header, blue sections
│   │   ├── master.tex          # Sample CV content
│   │   ├── master.pdf          # Preview of this template's styling
│   │   └── preamble.tex        # Layout and styling definitions
│   ├── gogo/                   # Clean professional style by Listiarso Wastuargo
│   │   ├── master.tex
│   │   ├── master.pdf          # Preview of this template's styling
│   │   └── preamble.tex
│   └── harshibar/              # Minimal style based on Jake Yang's template
│       ├── master.tex
│       ├── master.pdf          # Preview of this template's styling
│       └── preamble.tex
├── prompts/                    # AI prompt templates for CV operations
│   └── job_desc_match.md       # CV-to-job-description matching prompt
├── v1/                         # Your personalized CV (created from a template)
│   ├── master.tex              # Your CV - references preamble from templates/
│   └── <company>/              # Job-specific variant
│       ├── main.tex            # Optimized CV for this application
│       └── job_desc.md         # Target job description
└── .devcontainer/              # Docker dev container config

Strategic design: The templates/ folder is read-only infrastructure—never edit these directly. The v1/ folder is your workspace, and each job application gets a subfolder containing both the optimized CV and the source job description. This creates a deterministic audit trail: you can always trace why a particular bullet was written by checking the job_desc.md in that folder. The prompts/ directory acts as your AI's instruction manual, ensuring consistent, high-quality outputs across different agents.

Example 3: Template Initialization Commands

These shell commands demonstrate the exact workflow for setting up your personal CV space. They appear in the "Choosing a Template" section:

# Step 1: Remove the existing placeholder v1 directory
# This ensures you start with a clean slate, free of sample content
rm -rf v1/

# Step 2: Create a fresh v1 directory for your personal CV
mkdir v1

# Step 3: Copy the CONTENT file from your chosen template
# Note: You're copying master.tex (content), NOT preamble.tex (styling)
cp templates/gergely/master.tex v1/

# Step 4: Edit v1/master.tex to reference the template's preamble
# Open the file and change the first line to:
# \input{../templates/gergely/preamble}
# This links your content to the styling definitions

Why this matters: The separation is absolute. You could delete the entire templates/ folder and your v1/master.tex would still be valid content—you'd just need a new preamble. This is the same principle as separating HTML from CSS or logic from presentation in MVC frameworks. The commands enforce this architecture by making you consciously choose and link a template.

Example 4: Mac ARM Manual Installation

For developers who prefer native tooling over Docker, here are the precise installation commands:

# Install MacTeX without GUI components (saves ~3GB)
brew install --cask mactex-no-gui

# Configure PATH for TeX binaries
# Option A: Use macOS path_helper (recommended)
eval "$(/usr/libexec/path_helper)"

# Option B: Manual PATH export (replace YYYY with your version)
# Example: /usr/local/texlive/2024/bin/universal-darwin
export PATH="/usr/local/texlive/YYYY/bin/universal-darwin:$PATH"

# Verify installation and test compilation
latexmk -pdf templates/harshibar/master.tex

# If compilation fails due to missing packages, install them:
sudo tlmgr install fontawesome5 etoolbox hyperref

Technical deep dive: mactex-no-gui installs the full TeX Live distribution but skips TeXShop and other GUI apps. The path_helper command reads from /etc/paths and /etc/paths.d/, where MacTeX registers its binary location. The latexmk command is a Perl script that orchestrates multiple LaTeX passes, BibTeX runs, and PDF generation automatically—it's the make tool for LaTeX. If you see "command not found," your PATH is misconfigured. If you see "package not found," use tlmgr (TeX Live Manager) to install dependencies.

Advanced Usage & Best Practices

Master the Agent Prompting Workflow: Don't just paste job descriptions—structure them for your AI. Extract the "Requirements" and "Responsibilities" sections separately, then feed them to the agent with explicit instructions: "Rewrite bullets 3-5 to emphasize these keywords." Use the chain-of-thought technique by asking the agent to "first analyze the keyword density, then suggest three alternatives for each bullet, then select the best one." This produces far superior results than generic requests.

Create a Prompt Versioning System: Treat your AI prompts like code. When you discover a prompt pattern that generates exceptional bullets, commit it to a new file in prompts/ with a descriptive name like ats_keyword_injection.md. Document the date, the AI model used, and the success rate. Over time, you'll build a personal library of proven prompts that work specifically for your writing style and target roles.

Leverage Git Hooks for Automation: Add a pre-commit hook that automatically compiles your LaTeX and checks for common errors:

#!/bin/sh
# .git/hooks/pre-commit
latexmk -pdf v1/master.tex
if [ $? -ne 0 ]; then
  echo "LaTeX compilation failed. Fix errors before committing."
  exit 1
fi

This ensures you never commit broken source files. For extra power, add a post-commit hook that uploads the PDF to a private S3 bucket or Notion database, creating a cloud backup of every version.

Build a Metrics Dashboard: Track your CV's performance like a product. Create a simple Markdown file v1/performance_metrics.md where you log:

• Date submitted
• Company and role
• Template used
• ATS score (if available via tools like Jobscan)
• Interview outcome

After 20+ applications, you'll have data showing which templates and bullet styles correlate with interviews. This turns CV optimization from art into science.

Integrate with Your Job Search CRM: Use the job-specific subfolders (v1/<company>/) to store not just the CV and job description, but also:

• interview_notes.md
• follow_up_email.txt
• salary_expectations.txt

This transforms your v1/ directory into a comprehensive job search command center, all under version control.

Comparison with Alternatives

Why Vibe-CV-Resume Wins for Developers: Overleaf is fantastic for beginners but becomes a bottleneck when you want to automate workflows. You can't script Overleaf, and its AI features are surface-level. Traditional LaTeX gives you full control but requires manual setup of the entire agentic pipeline—vibe-cv-resume gives you pre-built, tested prompts. Word is a non-starter for anyone serious about precision typography and version control. The killer feature is the pre-built agent prompts that understand LaTeX syntax; you don't have to reinvent the wheel teaching AI about \item commands.

Frequently Asked Questions

Q: Do I need to know LaTeX to use this? A: Absolutely not. The templates handle all styling; you only edit plain text content. The AI agents understand LaTeX syntax, so they won't break anything. Think of it like using a framework—you write JSX, not raw HTML.

Q: Will AI-generated content make my CV sound robotic? A: The prompts are designed to preserve your voice while optimizing structure. They add metrics and action verbs but keep your core achievements. Always review and edit the AI's suggestions—it's a collaborative tool, not an autopilot.

Q: How does this compare to Jobscan or other ATS tools? A: Jobscan analyzes your CV against a job description and gives you a score. Vibe-cv-resume goes further—it automatically rewrites your CV to improve that score. It's the difference between a linter and an auto-fix tool.

Q: Can I use this with my current AI subscription? A: Yes! The prompts work with Claude (via Claude Desktop), Cursor (built-in), or GPT-4 (via API or ChatGPT). You're already paying for these tools—this squeezes more value from that investment.

Q: What if I need a custom template? A: The existing templates are highly customizable. Edit the preamble.tex files to change colors, fonts, or layouts. For entirely new designs, create a new folder in templates/ following the existing structure. The community welcomes contributions!

Q: Is the Docker approach slower than native compilation? A: Surprisingly, no. The dev container caches TeX packages and uses volume mounts, so compilation is nearly as fast as native. The first build takes 2-3 minutes, but subsequent compiles are sub-second. The tradeoff is zero local installation headaches.

Q: How do I handle confidential information in a public GitHub repo? A: Two strategies: (1) Use a private GitHub repository for your personal fork. (2) Keep sensitive details (phone, email) in a separate secrets.tex file that's .gitignored, and reference it with \input{secrets}. The AI can still optimize your content without exposing private data.

Conclusion: Your Career Deserves Developer-Grade Tools

Vibe-cv-resume isn't just a resume builder—it's a declaration that career management should leverage the same engineering excellence we apply to code. By combining LaTeX's typographic precision, Git's versioning superpowers, and AI's linguistic intelligence, you create a CV maintenance system that's deterministic, scalable, and endlessly optimizable. The days of manually reformatting bullet points and losing track of which version you sent to which company are over.

What excites me most is the agentic workflow. You're not just editing a document; you're pair-programming with AI on your career narrative. Each prompt execution is a commit. Each job application is a feature branch. Your interview success rate becomes a metric you can track, analyze, and improve. It's professional development meets software development.

The repository is production-ready today. The templates are battle-tested, the prompts are engineered for results, and the Docker setup eliminates friction. Whether you're a junior developer applying to your first role or a staff engineer managing multiple specializations, this framework scales with you.

Take action now: Fork the repository at github.com/madnanrizqu/vibe-cv-resume, spin up the dev container, and run your first AI optimization. Your future self—sitting in that interview chair—will thank you for investing in a system that makes your achievements shine with the same precision you bring to your code.

Ready to revolutionize your resume workflow? Clone the repo, choose your template, and let AI agents transform how you present your professional story.