Community라이팅 & 에디팅github.com

resume-optimizer

Build or optimise a CV/resume for a specific job, following the Wonsulting Resume Playbook (6-second test, HAMS bullets - hard skill + action verb + metric + structure, JD skills mirroring, 80%+ bullets with metrics, no summary unless career switch, final 8-point checklist) learned from nine interview-winning resumes and six decoded Wonsulting videos. Source can be an existing CV (optimise it) or a LinkedIn profile, as a data-export ZIP, profile PDF, pasted text or URL (build a new CV from it, Stage 0). Then six stages - (1) CV X-Ray, a brutal senior-HR critique; (2) Job Description Decoder, hidden skills, red flags, must-have keywords, what the hiring manager really wants; (3) ATS Bypass Optimizer, every gap plus before/after rewrites with the JD's exact keywords and a measured keyword score; (4) Achievement Transformer, every bullet rewritten with HAMS; (5) Recruiter Mind Reader, the 6-second shortlist-or-skip scan; (6) Final CV Audit, every section scored out of 10 plus the play...

resume-optimizer란 무엇인가요?

resume-optimizer is a Claude Code agent skill that build or optimise a CV/resume for a specific job, following the Wonsulting Resume Playbook (6-second test, HAMS bullets - hard skill + action verb + metric + structure, JD skills mirroring, 80%+ bullets with metrics, no summary unless career switch, final 8-point checklist) learned from nine interview-winning resumes and six decoded Wonsulting videos. Source can be an existing CV (optimise it) or a LinkedIn profile, as a data-export ZIP, profile PDF, pasted text or URL (build a new CV from it, Stage 0). Then six stages - (1) CV X-Ray, a brutal senior-HR critique; (2) Job Description Decoder, hidden skills, red flags, must-have keywords, what the hiring manager really wants; (3) ATS Bypass Optimizer, every gap plus before/after rewrites with the JD's exact keywords and a measured keyword score; (4) Achievement Transformer, every bullet rewritten with HAMS; (5) Recruiter Mind Reader, the 6-second shortlist-or-skip scan; (6) Final CV Audit, every section scored out of 10 plus the play...

지원 대상✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/theommishra-dev/claude-skills/tree/HEAD/resume-optimizer

Installed? Explore more 라이팅 & 에디팅 skills: steipete/notion, langchain-ai/langchain, bytedance/podcast-generation · View all 6 →

즐겨 사용하는 AI에게 물어보기

이 에이전트 스킬이 미리 로드된 새 채팅을 엽니다.

문서

Resume Optimizer

Two ways in, one pipeline:

  • Optimise: the user has a CV. It goes straight into the six stages.
  • Build: the user gives a LinkedIn profile. Stage 0 turns it into a first CV draft built only from the profile's facts (plus anything the user confirms), then the same six stages make it job-ready.

Either way, it turns a CV plus a job description into a tailored, ATS-ready CV that scores 90+ on a final audit, through six stages that each play a different reader: senior HR, the hiring manager, an ATS, a CV writer, a rushed recruiter, and an auditor. Each stage writes a short report, so the user can see exactly what changed and why.

Read before running any stage:

  1. references/playbook.md: the rulebook (based on the Wonsulting Resume Playbook; it wins wherever another rule disagrees). 6-second test, student vs professional section order, section-by-section rules, HAMS for every bullet, "translate any job", the 8-point final checklist and the mistakes that kill a CV.
  2. references/stages.md: instructions and report templates for every stage, wired to the playbook.
  3. references/style-guide.md: the LaTeX look, how to keep facts and confidentiality straight, and how to work with the user section by section.

Look up when needed: references/build-from-linkedin.md (Stage 0, LinkedIn source).

The goal: whatever comes in, even a weak CV, goes out passing every playbook rule with the score measured. The ranking of rules: honesty and the user's confidentiality first, then playbook.md, then everything else. Never promise interviews; promise a CV with nothing left for a recruiter to skip it for.

Inputs

  • Source, one of:
    • CV: a .pdf, .docx, .md or .txt path, or pasted text. If the user says "my CV" without a path, look in the current folder (and a CV/ folder if there is one) first; if there are several, use the newest and say which one.
    • LinkedIn profile: data-export ZIP (richest), profile "Save to PDF" (fastest, but only the top 3 skills), pasted text, or a URL. Tell a LinkedIn PDF apart from a CV by its layout: a "Contact / Top Skills" sidebar, "Page 1 of N" footers, and an "About" section. If a saved master profile already exists (linkedin_master_*.md) and the user doesn't give a newer source, reuse it (say which date it is from).
    • Both: use the LinkedIn profile as the fact source and the CV for layout and anything LinkedIn lacks; flag every place they disagree.
  • Job description: pasted text, a file, or a URL (fetch it with WebFetch; for LinkedIn job links that WebFetch can't read, the agent-reach skill can). Without a JD, Stages 1, 4 and 6 still work against the role the CV is aiming for; Stages 2, 3 and 5 need one, so ask for it before those.
  • Industry / target role: infer from the JD, else from the CV. Ask only if both are unclear.

Modes

  • Build (source is LinkedIn): Stage 0a extract the profile → 0b ask for what LinkedIn lacks → Stage 2 decode the JD → 0c draft cv_v0.md for that job → stages 1, 3, 4, 5, 6. Decoding the JD before drafting means the draft is built for the job instead of rewritten afterwards. Without a JD, build a strong general CV for the role the profile points at, then stages 1, 4, 6.
  • Full run (default when the user gives a CV and a JD): stages 1 → 6 in order. Each stage feeds the next: the X-Ray finds problems, the decoder sets the target, Stage 3 and 4 rewrite, Stage 5 checks first impressions, Stage 6 signs off.
  • Single stage: the user names one ("just decode this JD", "rewrite my bullets", "audit my CV"). Run only that one, using any earlier stage files that already exist for this application.
  • General polish (CV, no JD): stages 1, 4, 6, scored without keyword coverage.

When the user wants to review a CV section by section, follow the "Working with the user" rules in references/style-guide.md (draft, test-build a scratch copy, show, apply only after they say go; never touch approved sections). Otherwise, pause for the user only when it changes the result: in build mode after 0b (contact details and numbers LinkedIn doesn't have), and once after Stage 4 with one batched list of every question: Stage 3's "ask first" items, Stage 4's [VERIFY: ...] numbers, and always the short-summary option (the drafted 2-3 line summary shown in full, "include it: yes / no / edit"; playbook.md 3.5), each answerable in a line. With no questions to ask, still offer the summary before the final build. (With a weak CV most bullets depend on the answers, so draft them with whole-claim placeholders rather than pausing twice.) After the answers, rewrite the affected bullets, then run Stages 5 and 6. Everything else runs straight through.

[VERIFY: ...] marks any unconfirmed claim, not just numbers: a number ([VERIFY: ~30%]), a tool or activity ([VERIFY: built in Power BI?]) or a whole bullet that stays only if true ([VERIFY: keep only if you built this dashboard]). ats_check.py ignores everything inside placeholders, so a draft can't pass the keyword or metric checks on unconfirmed text.

Testing the skill: tests/bad_cv_demo/ holds a fictional weak CV, a JD and hidden_facts.md (the persona's answers, never shown to the run before it asks). Write a test run to tests/bad_cv_demo/run/ instead of a real application folder, and don't touch the tracker. A finished example run is already in tests/bad_cv_demo/run/.

Where things go

One folder per application, so versions never get mixed:

applications/
├── cv/                                   master CVs (date in file name)
└── applications/
    ├── tracker.md                        company | role | date | status | next step
    └── <Company>_<Role>_<YYYY-MM-DD>/
        ├── jd.md                         the JD as given (keep it: postings disappear)
        ├── cv_original.<ext>             untouched copy of the input CV (optimise mode)
        ├── 00_profile.md                 extracted LinkedIn profile + questions + "LinkedIn updates to make" (build mode)
        ├── cv_v0.md                      first draft built from the profile (build mode)
        ├── 01_xray.md
        ├── 02_jd_decoded.md
        ├── keywords.json
        ├── 03_ats.md
        ├── 04_achievements.md
        ├── 05_recruiter.md
        ├── 06_audit.md
        ├── cv.json                       the finished CV content: the single source for the build
        ├── cv_final.md                   Markdown copy of cv.json (written by build_cv.py --md)
        ├── cv_final.tex                  LaTeX source (written by build_cv.py)
        └── cv_final.pdf                  the file to send (compiled with pdfLaTeX)

For general polish or a general build without a JD, use cv/_polish_<YYYY-MM-DD>/ or cv/_build_<YYYY-MM-DD>/. In build mode also save the extracted profile as cv/linkedin_master_<YYYY-MM-DD>.md, so the next application starts from it. Add or update the row in tracker.md at the end (status "CV ready" or "CV blocked: ").

Use any folder you like; this is only a suggested structure. Create folders as needed.

The scripts

scripts/linkedin_export.py <zip|folder> -o 00_profile.md turns a LinkedIn data export into one markdown master profile (experience, education, all skills, certifications, projects, languages, honors, recommendations), skipping connections, messages and other noise.

scripts/ats_check.py

makes the "ATS score" a measurement instead of a guess. Run it with Python 3 (it uses pypdf for PDFs: pip install pypdf):

python3 scripts/ats_check.py text  <cv-file>
python3 scripts/ats_check.py score <cv-file> <keywords.json>

text shows what an ATS can actually extract: if the header, skills or a whole column is missing, the CV is failing for format reasons no rewrite will fix. score gives weighted keyword coverage (must-have ×3, important ×2, nice ×1) plus hygiene and playbook checks: weak or adverb openers (HAMS A), share of bullets with a number below 80% (HAMS M), filler phrases, first person, an Objective section, soft skills in Skills (all blocking); and as notes for the auditor: a summary present, skills never shown in a bullet, a year in Education, bullets over 40 words. With no JD yet, pass an empty {} keywords file to get the checks alone. Tell the user it is a coverage estimate, not any vendor's real ATS score, because each ATS ranks differently; what they all share is matching the JD's terms in parseable text, and that is what this measures.

scripts/build_cv.py turns cv.json into the final CV: it writes a self-contained .tex from a layout template (templates/cv_<layout>.tex), compiles it with latexmk/pdfLaTeX, and checks the PDF (page count against style.max_pages, extracted text, hygiene, [VERIFY left). The cv.json shape is in the script's docstring.

python3 scripts/build_cv.py <folder>/cv.json \
    -o <folder>/cv_final.pdf --md <folder>/cv_final.md      # .tex lands next to the PDF (or --tex <path>)

It ends with READY TO SEND or NOT READY: n item(s); the PDF is only sendable on the first.

Honesty rules

The user asked for brutal and is relying on this CV in real interviews, so:

  • Be brutal about the CV, never about facts. Every criticism quotes the line and gives the fix.
  • Never invent experience, skills, titles, employers, dates or degrees. In build mode, every line of the CV must trace back to the profile or to something the user said in this session. Stage 3 sorts every gap into can claim / ask first / cannot claim, and "cannot claim" items stay out of the CV and go into a "real gaps" list with how to close them. A keyword the user can't defend in an interview gets them rejected later, and more painfully.
  • Numbers the user didn't give are placeholders, visibly marked [VERIFY: ...], realistic for the role, and the CV is not "ready to send" while any remain. The playbook's "quantify everything (even estimate them)" means the user's estimate: we propose, they confirm. HAMS demands a metric in every bullet; that is a reason to ask, never to invent.
  • No keyword stuffing: no hidden text, no buzzword blocks, each keyword where it is true.
  • Keep employers' confidential details out: no internal counts (number of rules, hosts, alerts), customer names, internal system or host names, ticket IDs or URLs, unless the user has already made them public (e.g., on LinkedIn). Work notes and wikis are fact sources, not copy sources: take the skill and the outcome, leave the internals.
  • If the honest ceiling is under 90, say so and give the real number.

Final CV output

The CV is built and compiled in LaTeX in the classic layout with the style block from references/style-guide.md, unless the user asks for something else. It needs a TeX distribution with pdflatex and latexmk (TeX Live or MacTeX); if it is missing, say so instead of switching formats silently.

  1. Put the finished content into cv.json (sections in the order they should print; **bold** for the few words Stage 5 says to bold).
  2. Run build_cv.py (above). It writes cv_final.tex, cv_final.pdf and, with --md, cv_final.md.
  3. Look at it: render page 1 (sips -s format png -Z 1700 cv_final.pdf --out page1.png on macOS, or pdftoppm -png -r 100) and read the image. Check alignment, wrapping of the date column, and spare space.
  4. Over the page target? See "To fit one page" below.

The template keeps the PDF ATS-safe, so don't undo these when tweaking the look: single column, standard headings (Experience, Education, Skills, plus Projects/Leadership/Certifications/Languages when relevant; Summary only when the playbook allows it), one font, no tables, text boxes, icons, graphics or skill bars, name and contact in the body (not a page header), glyphtounicode + \pdfinterwordspaceon (real Unicode and real spaces in the extracted text), no ligatures, no hyphenation, no letter-spaced headings. Layouts (style.layout): classic is the default and the default look: centred serif header (name in capitals, title line, contact line joined by |), a 1 pt black rule, small-caps-style section headings with a thin rule, title and dates on one line, organisation and location in italics on the next, Charter font (times available: the playbook video recommends Times New Roman), everything black, minimal. compact is the alternative: left-aligned header, sans font, one accent colour, entries on one line. Fonts via style.font: charter (classic default), times, sourcesans (compact default), helvetica, roboto, lmodern. Keep classic black unless the user asks for colour.

To fit one page, in this order: cut words and weak entries (a skills line that wraps by one word, a bullet whose last line is two words), then section_before/itemsep (pt), then margin_cm (down to 1.2), and only then body_pt (never below 10: playbook video).

The .tex is regenerated from cv.json on every build, so make lasting changes in the JSON (or the layout template for the look). For a one-off hand edit, edit the .tex and compile it with latexmk -pdf cv_final.tex.

Word file only when a portal or recruiter demands .docx: build it from the same content with the anthropic-skills:docx skill, following the same layout rules, and say that the LaTeX PDF remains the main file.

Match the job market's conventions. The playbook is US-based; these market rules sit on top of it. For Europe/Italy: "CV" is normal; two pages is fine with substantial experience (roughly 5+ years), one page otherwise; no photo by default (playbook video: it invites bias), add one only if the user asks for a market that expects it; avoid the Europass template, which recruiters read as junior; Italian applications usually end with the data-processing consent line ("Autorizzo il trattamento dei miei dati personali ai sensi del Regolamento UE 2016/679 (GDPR)"), so add it for Italy-based roles unless the user says not to ("footer" in cv.json). Write the CV in the posting's language.

Finish

End with a short summary in chat: the before → after audit score (in build mode: the score of cv_v0 → final), before → after keyword coverage, before → after share of bullets with a metric, the 8 playbook checks (all pass, or which fail and why), the three biggest changes, anything still blocking, and the path to the file to send. In build mode, also list the "LinkedIn updates to make" so the profile matches the CV recruiters will compare it with. Point to the stage reports for detail rather than repeating them.

관련 스킬