resume-assistant（简历助理）

📝 Resume / CV Assistant

AI-powered clawbot skill for resume & CV polishing, job customization, multi-format export, and professional scoring.

Version: 1.0.0 · License: MIT · Repository: github.com/Wscats/resume-assistant

Overview

Resume / CV Assistant is a clawbot skill that helps job seekers create, refine, and optimize their resumes and CVs, while adding comprehensive checklist review, scoring, and multi-format export that neither project offers alone.

Usage in AI Agent

Quick Start

Resume / CV Assistant is a standard clawbot skill that can be loaded and invoked by any compatible AI Agent. Here are different integration approaches.

💬 Natural Language (Recommended)

You don't need to memorize any commands — simply describe what you need:

💬 "Create a resume for a software engineer position"
💬 "Polish my resume and fix any issues"
💬 "Optimize my resume for ATS"
💬 "Tailor my resume for this job description: [paste JD]"
💬 "Convert my resume to PDF"
💬 "Score my resume and tell me how to improve"
💬 "What's wrong with my resume?"
💬 "Here's my resume, can you help?"

The assistant understands your intent and automatically routes to the right workflow:

Example Conversations

Creating a new resume:

You:   Create a resume for a frontend engineer position at a startup

Bot:   I'd be happy to help! To get started, could you share:
       1. Your work experience (companies, roles, dates, key achievements)
       2. Education background
       3. Technical skills
       4. Any specific job posting you're targeting? (optional)

You:   I have 3 years at Shopify working on React...

Bot:   Here's your tailored resume:
       [generates complete resume]
       
       Would you like me to score, polish, or export it?

Quick improvement:

You:   Here's my resume, what do you think?
       [pastes resume]

Bot:   📊 Resume Score: 68/100 (Grade: C)
       Top 3 Issues:
       1. ❌ No quantified achievements
       2. ⚠️ Weak action verbs
       3. ⚠️ Missing keywords for target role
       
       Would you like me to polish it now?

You:   Yes, polish it

Bot:   [runs full polish with 40+ checklist items]

Job-specific tailoring:

You:   Tailor my resume for this job description:
       Senior Backend Engineer at Stripe
       Requirements: Go, distributed systems, payment APIs...

Bot:   🎯 Job Analysis Complete
       📊 Current Match: 62% → After Optimization: 89%
       [generates tailored version]

Option 1: Slash Commands via clawbot

For more precise control, use slash commands directly in a clawbot conversation:

/resume polish
Please polish my resume:

John Doe
Senior Frontend Engineer | 5 years experience
Skills: JavaScript, React, Vue, Node.js
...

Option 2: Integration in AI Agent Frameworks

1. Register the Skill

Register this project as a skill in your AI Agent:

{
  "skills": [
    {
      "name": "resume-assistant",
      "path": "./skills/resume-assistant",
      "manifest": "skill.json"
    }
  ]
}

2. Load Prompts

When handling resume-related requests, prompt files are loaded in this order:

1. prompts/system.md      ← Persona & quality standards (loaded first)
2. prompts/<command>.md    ← Load per command: specific instructions
3. templates/<style>.md    ← Load on demand (export command only)

3. Build the Complete Prompt

Example for /resume polish — here's how an AI Agent should construct the prompt:

# Python pseudocode
ROLE_SYS = "system"    # LLM message role constant
ROLE_USR = "user"      # LLM message role constant

def build_prompt(command, args):
    # Step 1: Load the skill persona prompt
    persona_prompt = load_file("prompts/system.md")

    # Step 2: Load command-specific prompt
    command_prompt = load_file(f"prompts/{command}.md")

    # Step 3: Combine prompts into LLM messages
    combined = persona_prompt + "\
\
" + command_prompt
    messages = [
        {"role": ROLE_SYS, "content": combined},
        {"role": ROLE_USR, "content": args["resume_content"]}
    ]

    # Step 4: Add optional parameters to user message
    if args.get("language"):
        messages[1]["content"] += f"\
\
Language: {args['language']}"

    return messages

// JavaScript pseudocode
const ROLE_SYS = 'system';  // LLM message role constant
const ROLE_USR = 'user';    // LLM message role constant

async function buildPrompt(command, args) {
  // Step 1: Load the skill persona prompt
  const personaPrompt = await loadFile('prompts/system.md');

  // Step 2: Load command-specific prompt
  const commandPrompt = await loadFile(`prompts/${command}.md`);

  // Step 3: Combine prompts into LLM messages
  const combined = `${personaPrompt}\
\
${commandPrompt}`;
  const messages = [
    { role: ROLE_SYS, content: combined },
    { role: ROLE_USR, content: args.resume_content }
  ];

  // Step 4: Add optional parameters
  if (args.language) {
    messages[1].content += `\
\
Language: ${args.language}`;
  }

  return messages;
}

Option 3: REST API

If your AI Agent exposes an HTTP API, invoke via RESTful endpoints:

# Polish a resume
curl -X POST https://your-agent-api.com/skills/resume-assistant/polish \
  -H "Content-Type: application/json" \
  -d '{
    "resume_content": "Your resume content...",
    "language": "en"
  }'

# Score a resume
curl -X POST https://your-agent-api.com/skills/resume-assistant/score \
  -H "Content-Type: application/json" \
  -d '{
    "resume_content": "Your resume content...",
    "target_role": "Senior Frontend Engineer",
    "language": "en"
  }'

# Customize for a job
curl -X POST https://your-agent-api.com/skills/resume-assistant/customize \
  -H "Content-Type: application/json" \
  -d '{
    "resume_content": "Your resume content...",
    "job_description": "Job description...",
    "language": "en"
  }'

# Export to a format
curl -X POST https://your-agent-api.com/skills/resume-assistant/export \
  -H "Content-Type: application/json" \
  -d '{
    "resume_content": "Your resume content...",
    "format": "html",
    "template": "modern"
  }'

Option 4: LangChain / LlamaIndex Integration

from langchain.tools import Tool

# Define tools based on skill.json commands
resume_tools = [
    Tool(
        name="resume_polish",
        description="Polish and improve resume with 40+ checklist items",
        func=lambda input: agent.run_skill(
            "resume-assistant", "polish",
            {"resume_content": input, "language": "en"}
        )
    ),
    Tool(
        name="resume_score",
        description="Score a resume on 100-point scale with improvement suggestions",
        func=lambda input: agent.run_skill(
            "resume-assistant", "score",
            {"resume_content": input, "language": "en"}
        )
    ),
    Tool(
        name="resume_customize",
        description="Customize resume for a specific job position",
        func=lambda input: agent.run_skill(
            "resume-assistant", "customize",
            {"resume_content": input.split("---JD---")[0],
             "job_description": input.split("---JD---")[1],
             "language": "en"}
        )
    ),
    Tool(
        name="resume_export",
        description="Export resume to Word/Markdown/HTML/LaTeX/PDF",
        func=lambda input: agent.run_skill(
            "resume-assistant", "export",
            {"resume_content": input, "format": "html", "template": "modern"}
        )
    ),
]

Command Routing

The AI Agent should route user requests to the correct command:

graph TD
    A["User Input"] --> B{"Contains<br/>slash command?"}
    B -- "Yes" --> C{"Parse command"}
    C -- "/resume polish" --> D["Load polish.md"]
    C -- "/resume customize" --> E["Load customize.md"]
    C -- "/resume export" --> F["Load export.md"]
    C -- "/resume score" --> G["Load score.md"]
    B -- "No" --> H{"Intent detection"}
    H -- "polish/improve/fix" --> D
    H -- "job/apply/match" --> E
    H -- "export/download/convert" --> F
    H -- "score/rate/evaluate" --> G
    D --> I["Build Prompt<br/>Call LLM"]
    E --> I
    F --> I
    G --> I
    I --> J["Return Result"]

Argument Validation

The AI Agent should validate arguments before invocation, referencing skill.json:

def validate_args(command, args):
    """Validate arguments against skill.json schema."""
    schema = load_skill_json()
    cmd_schema = next(c for c in schema["commands"] if c["name"] == command)

    for arg in cmd_schema["arguments"]:
        # Check required fields
        if arg["required"] and arg["name"] not in args:
            raise ValueError(f"Missing required argument: {arg['name']}")

        # Check enum constraints
        if "enum" in arg and arg["name"] in args:
            if args[arg["name"]] not in arg["enum"]:
                raise ValueError(
                    f"Invalid value for {arg['name']}: {args[arg['name']]}. "
                    f"Must be one of: {arg['enum']}"
                )

        # Apply defaults
        if arg["name"] not in args and "default" in arg:
            args[arg["name"]] = arg["default"]

    # Check max resume length
    max_len = schema["config"]["max_resume_length"]
    if len(args.get("resume_content", "")) > max_len:
        raise ValueError(f"Resume exceeds {max_len} character limit")

    return args

Commands

/resume polish

Run a 40+ item checklist across 8 categories and get a fully improved resume.

Arguments:

What you get:

• ✅/❌/⚠️ checklist results for every item (contact, summary, experience, education, skills, grammar, formatting, ATS)
• Fully polished resume with strong action verbs and quantified results
• Change summary categorized by priority: 🔴 Critical → 🟡 Major → 🟢 Minor → 💡 Suggestion
• Action verb reference table and quantification guide

/resume customize

Tailor your resume for a specific job posting with gap analysis and keyword optimization.

Arguments:

What you get:

• Job description breakdown (required skills, preferred skills, responsibilities, keywords)
• Gap analysis matrix mapping every requirement to your resume
• Customized resume with keywords naturally integrated
• Keyword coverage report: before vs. after
• Bonus: cover letter talking points + interview prep notes

/resume export

Convert your resume to Word, Markdown, HTML, LaTeX, or PDF with professional templates.

Arguments:

Templates:

Export details:

• HTML: Self-contained file with embedded CSS, 4 color themes, @media print optimized
• LaTeX: Complete compilable .tex with XeLaTeX + CJK support
• Word: Pandoc-optimized Markdown with YAML front matter + conversion command
• PDF: Print-optimized HTML with A4 page dimensions + multiple conversion methods
• Markdown: Clean, structured, version-control friendly

/resume score

Get a 100-point professional evaluation with specific improvement suggestions.

Arguments:

Scoring dimensions (100 points):

Grade scale: A+ (95-100) → A (90-94) → B+ (85-89) → B (80-84) → C+ (75-79) → C (70-74) → D (60-69) → F (<60)

What you get:

• Score breakdown with per-dimension justification
• Top 3 strengths with specific examples from your resume
• Priority-ranked improvements with Before → After rewrites
• Role fit assessment (if target_role provided): fit score, competitive percentile, strengths, gaps
• 5-step action plan with effort estimates

Recommended Workflow

┌──────────────────────────────────────────────────────┐
│                  Recommended Workflow                 │
├──────────────────────────────────────────────────────┤
│                                                      │
│  1. /resume score     ← Know where you stand         │
│     💬 "Score my resume"                             │
│          │                                           │
│          ▼                                           │
│  2. /resume polish    ← Fix all issues               │
│     💬 "Polish my resume"                            │
│          │                                           │
│          ▼                                           │
│  3. /resume customize ← Tailor per application       │
│     💬 "Tailor for this JD: ..."                     │
│          │                                           │
│          ▼                                           │
│  4. /resume export    ← Generate final files         │
│     💬 "Convert to PDF"                              │
│          │                                           │
│          ▼                                           │
│  5. /resume score     ← Verify improvement           │
│     💬 "Score my resume again"                       │
│                                                      │
└──────────────────────────────────────────────────────┘

Tips:

1. Start with score if you have an existing resume — understand your baseline
2. Polish to fix all fundamentals before customizing for a job
3. Customize separately for each application — one-size-fits-all doesn't work
4. Export last — get content perfect, then format
5. Use Markdown as your working format — it converts cleanly to all others
6. Score again after polish + customize to measure improvement

Project Structure

resume-assistant/
├── skill.json                    # Skill manifest (JSON)
├── skill.yaml                    # Skill manifest (YAML)
├── SKILL.md                      # This documentation
├── prompts/
│   ├── system.md                 # Persona definition & quality standards
│   ├── polish.md                 # Polish prompt: 40+ item checklist
│   ├── customize.md              # Customize prompt: gap analysis & keywords
│   ├── export.md                 # Export prompt: 5 formats × 4 templates
│   └── score.md                  # Score prompt: 100-point rubric
├── templates/
│   ├── professional.md           # Classic corporate template
│   ├── modern.md                 # Contemporary tech/startup template
│   ├── minimal.md                # Ultra-clean senior template
│   ├── academic.md               # Formal academic CV template
│   └── export/
│       ├── resume.html           # HTML template (4 CSS themes)
│       └── resume.tex            # LaTeX template (XeLaTeX + CJK)
└── examples/
    ├── sample-resume-en.md       # English sample (high quality)
    ├── sample-resume-zh.md       # Chinese sample (high quality)
    ├── sample-resume-weak.md     # Weak sample (for scoring demo)
    └── usage.md                  # Usage examples & workflow guide

Language Support

Configuration

scats