feat(ats): redesign to industry standard — skills-only extraction + Skills section

User hit Jobalytics/Resume Worded 61 with garbage injected ("Goals, Enterprise,
Authority, Productivity..."). Researched how ATS actually works; our approach
was backwards. Rebuilt to the standard.

- Extraction is SKILLS-ONLY: keep a term only if it's a recognised skill/tool/
method/domain in the gazetteer (_is_professional_term). Killed the "any
recurring/noun-suffix word" rule that produced prose-noun garbage. Expanded
vocab with common PM JD terms (use cases, business objectives, market trends).
- Re-introduced a categorized SKILLS section (Resume.skills + renderer
_write_skills): Tools & Analytics / Methodologies / Domains / Core, one clean
line each, after the summary. The #1 ATS keyword vehicle (reverses old task
to remove it).
- v4 populates Skills with the JD's real skills (taxonomy-first, ~26 cap), keeps
contextual bullet weaving, and RETIRES the summary-noun injection (stuffing
that real checkers penalised).
- Buzzword list fixed: keep real soft skills (communication/leadership/
collaboration); drop only filler + prose nouns.
- Postcondition: allow a clean categorized Skills section, still ban 15+-sep
dump lines. Acronym casing (SIEM/SOAR/XDR/SecOps/PLG/ROI/CAC/LTV/NPS).

Verify: worst-case 75-92, production 78-91, zero garbage, ~75% coverage
(best-practice 60-80%). Internal numbers are honest (lower than the prior
stuffed 87-94); real-checker scores should rise. Verify on Resume Worded/
Jobalytics.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

HISTORY.md

@@ -4,6 +4,55 @@ A running log of everything built, fixed, and changed. Most recent first.
 
 ---
 
+## 2026-06-19 (3) — ATS redesign to the INDUSTRY STANDARD (skills section)
+
+User hit a real disaster: Jobalytics 61% / Resume Worded 61, with an injected
+garbage line ("Further strengths span Goals, Enterprise, Generation,
+Organisation, Authority, Ai Technology, Repetitive Tasks, Productivity"). I
+researched how ATS checkers actually work ([Interview Guys](https://blog.theinterviewguys.com/what-ats-looks-for-in-resumes/),
+[Jobscan](https://www.jobscan.co/blog/resume-keyword-stuffing/), [Jobalytics](https://jobalytics.app/),
+[uppl.ai](https://www.uppl.ai/ats-resume-keywords)) and found our whole approach
+was backwards. Rebuilt to match the standard.
+
+### Root causes
+- **We extracted words, not skills.** A "keep any recurring/noun-suffix word"
+  rule grabbed prose nouns (Goals, Authority, Enterprise, Productivity,
+  Generation, Organisation) — none of which any real ATS treats as keywords.
+- **We injected ~100 keywords as filler sentences** — the opposite of best
+  practice (15–25 keywords, each 1–3×). Real ATS detect this as stuffing.
+- **We had deleted the Skills section** — yet a dedicated, standard-headed
+  Skills section is the #1 ATS keyword vehicle (Jobalytics literally scores
+  "Hard Skills"). Deleting it was wrong.
+- **We over-removed real soft skills** (communication, leadership,
+  collaboration) as "buzzwords" — but those are keywords checkers reward.
+
+### The redesign (user approved both decisions)
+- **Extraction is skills-only** (`_extract_content_terms`): a discovered term
+  is kept only if it's a recognised skill/tool/method/domain/soft-skill in our
+  gazetteer. Prose nouns can no longer appear. Expanded the vocab with common
+  PM JD terms (use cases, business objectives, market trends, user personas…).
+- **Re-introduced a categorized SKILLS section** (`Resume.skills` + renderer
+  `_write_skills`): Tools & Analytics / Methodologies / Domains / Core
+  Competencies, one clean line each (≤12 items), placed after the summary.
+- **Quality coverage, not stuffing**: v4 populates the Skills section with the
+  JD's real skills (taxonomy-first, ~26 cap), keeps contextual bullet weaving,
+  and **retired the summary-noun injection** entirely.
+- **Buzzword list fixed**: keeps real soft skills, drops only true filler
+  (innovation, solutions, world-class, robust, leverage…) + prose nouns.
+- **Postcondition updated**: a clean categorized Skills section is allowed; a
+  raw 15+-separator dump line is still banned. Acronym casing
+  (SIEM/SOAR/XDR/SecOps/PLG/ROI/CAC/LTV/NPS…).
+
+### Outcome (`scripts/verify_honest_scores.py`)
+- Worst-case stub 75–92, production 78–91, **zero garbage**, coverage ~75%
+  (best-practice target 60–80%). The Skills section reads like a real resume.
+- These internal numbers are lower than the previous *stuffed* 87–94 — because
+  the padding is gone. The REAL Resume Worded/Jobalytics score should *rise*:
+  we removed the buzzword penalty + garbage they flagged and added the Skills
+  section they reward. Verify externally.
+
+---
+
 ## 2026-06-19 (2) — Smart fill: keep ALL keywords (distributed), drop buzzwords
 
 User feedback on a Resume Worded screenshot (scored 74, top fix = "Buzzwords 7"):

README.md

@@ -223,14 +223,19 @@ Hybrid scoring: **70% JD Match + 30% Resume Quality**
 - **Iterative optimization**: Up to 3 LLM attempts to push score up, gap report fed back each iteration
 - **Fallback**: `_inject_missing_keywords()` weaves still-missing terms naturally
 
-### Keyword extraction is JD-driven, meaningful, and honest
-
-- Keywords are extracted **from each JD itself** (not a fixed stored list) and
-  **uncapped** — a JD with 50 meaningful terms yields 50. Extraction keeps real
-  nouns/skills (known skills, recurring terms, noun-suffix words, genuine skill
-  phrases) and **drops JD prose** (one-off verbs/adjectives, locations, company
-  names). This matches what real checkers like Jobalytics actually extract
-  (~35–55 terms), so our denominator isn't inflated.
+### Keyword extraction is JD-driven, skills-only, and honest (industry standard)
+
+- Keywords are extracted **from each JD itself** (not a fixed stored list), but
+  **skills-only**: a term is kept only if it's a recognised skill/tool/method/
+  domain/soft-skill in our gazetteer. Prose nouns (Goals, Authority, Enterprise,
+  Productivity…) can never become "keywords" — exactly how real checkers like
+  Jobalytics work (they match against a curated skills list, not every word).
+- **Dedicated, categorized SKILLS section** (Tools & Analytics / Methodologies /
+  Domains / Core Competencies) — the #1 ATS keyword vehicle, placed after the
+  summary, parsed and counted by Jobalytics/Resume Worded.
+- **Quality over quantity**: cover the JD's real skills (~20–26), each 1–3×,
+  across the skills section + summary + woven bullets. Best practice is 15–25
+  keywords at 60–80% coverage — NOT 100 stuffed terms.
 - **No cap, distributed smartly.** Every meaningful missing keyword is kept —
   woven into relevant bullets first (the ideal, never-penalised place), then any
   remainder spread across several short sentences (each its own paragraph, ≤10

src/ats_scorer.py

@@ -279,6 +279,18 @@ GENERIC_PROFESSIONAL_VOCAB = {
     "quantitative", "qualitative", "sql", "excel", "spreadsheets",
     "tableau", "looker", "powerbi", "amplitude", "mixpanel", "ga4",
     "jira", "confluence", "figma", "notion", "asana", "miro",
+    # ── Common PM/business JD terms real checkers extract (so coverage stays
+    # high now that extraction is skills-only). Multi-word forms also live in
+    # PM_SKILL_PHRASES via the taxonomy; these single tokens + phrases fill gaps
+    # seen on real PM JDs (Ema/Jobalytics): use cases, business objectives, etc.
+    "use cases", "use case", "business objectives", "market trends",
+    "user personas", "customer support", "product strategy", "product vision",
+    "product development", "product management", "product manager",
+    "product features", "product requirements",
+    "competitor analysis", "competitive", "roadmapping", "gap analysis",
+    "performance tracking", "iteration", "go-to-market strategy",
+    "cross-functional collaboration", "senior management",
+    "user-friendly", "milestones", "timelines",
 }
 
 
@@ -854,32 +866,17 @@ def _extract_content_terms(jd_text: str, max_terms: int = 0) -> List[str]:
             bg = f"{w1} {w2}"
             bigram_freq[bg] = bigram_freq.get(bg, 0) + 1
 
-    # Keep MEANINGFUL unigrams only — match what real ATS checkers (Jobalytics)
-    # actually extract: nouns/skills, not JD prose. A discovered word that isn't
-    # a known skill is kept only if it carries a strong NOUN-forming suffix or
-    # recurs AND is not an obvious verb/adjective form. Prose verbs/gerunds/
-    # adjectives (respond, defend, evolving, collaborating, reliable, prioritize)
-    # are dropped: stuffing them never raises a real-checker score and reads as
-    # filler. (Real skills like "marketing"/"onboarding"/"testing" survive via
-    # the professional-term vocab, not via a blanket -ing rule.)
-    _NOUN_SUFFIX = (
-        "tion", "sion", "ment", "ity", "ility", "ance", "ence", "ics",
-        "ism", "ist", "ology", "ware", "ization", "isation", "ship",
-        "ategy", "ategies", "analytics",
-    )
-    # Verb/gerund/adjective endings → prose unless they're known skills.
-    _PROSE_SUFFIX = ("ing", "ize", "ise", "ate", "ify", "able", "ible", "ous", "ive")
-
-    def _meaningful(t: str, c: int) -> bool:
-        if _is_professional_term(t):
-            return True
-        # Reject obvious verb/adjective prose forms outright.
-        if t.endswith(_PROSE_SUFFIX):
-            return False
-        # Strong noun suffix → keep. Otherwise require recurrence (emphasis).
-        return t.endswith(_NOUN_SUFFIX) or c >= 2
-
-    meaningful = {t: c for t, c in freq.items() if _meaningful(t, c)}
+    # SKILLS ONLY — match how real ATS checkers (Jobalytics/Resume Worded)
+    # actually work: they compare against a curated gazetteer of hard skills,
+    # tools, methods, domains, and real soft skills — NOT "any noun in the JD".
+    # We therefore keep a discovered unigram ONLY if it is a recognised
+    # professional term (in our skill vocab/taxonomy). This is what stops prose
+    # nouns like "Goals", "Enterprise", "Authority", "Productivity",
+    # "Generation", "Organisation" from ever being treated as keywords. Coverage
+    # of genuinely common PM/business terms comes from expanding the vocab, not
+    # from blindly grabbing every noun (which produced garbage and lowered the
+    # real-checker score).
+    meaningful = {t: c for t, c in freq.items() if _is_professional_term(t)}
     # Rank unigrams: known skills first, then frequency
     uni = sorted(meaningful.items(),
                  key=lambda x: (_is_professional_term(x[0]), x[1]), reverse=True)

src/resume_customizer.py

@@ -474,17 +474,22 @@ class ResumeCustomizer:
     # INJECT these — they are abstractions, not the concrete tools/methods/
     # domains that count as keywords. (They may still appear in a JD; we simply
     # don't stuff them into the resume.) General-purpose, not JD-specific.
+    # NOTE: real soft skills (communication, leadership, collaboration,
+    # stakeholder management, ownership) are NOT buzzwords — real checkers
+    # (Jobalytics) count them as keywords, so they are deliberately absent here.
+    # This set is ONLY vague filler/marketing fluff that adds no ATS value and
+    # gets flagged (Resume Worded "Buzzwords" fix). We never inject these.
     _BUZZWORDS = {
         "innovation", "innovative", "solutions", "solution", "tools", "tool",
-        "lifecycle", "problem-solving", "problem solving", "ownership",
-        "leadership", "communication", "collaboration", "collaborative",
-        "teamwork", "synergy", "dynamic", "passionate", "motivated",
-        "results-driven", "results driven", "detail-oriented", "detail oriented",
-        "team player", "track record", "expertise", "strengths", "strength",
-        "best practices", "value-add", "thought leadership", "self-starter",
-        "go-getter", "fast-paced", "cutting-edge", "world-class", "robust",
-        "scalable", "seamless", "holistic", "leverage", "leveraging",
-        "spearheaded", "passion", "excellence", "proven", "successful",
+        "synergy", "dynamic", "passionate", "motivated", "results-driven",
+        "results driven", "detail-oriented", "detail oriented", "team player",
+        "track record", "expertise", "strengths", "strength", "best practices",
+        "value-add", "thought leadership", "self-starter", "go-getter",
+        "fast-paced", "cutting-edge", "world-class", "robust", "seamless",
+        "holistic", "leverage", "leveraging", "spearheaded", "passion",
+        "excellence", "proven", "successful", "enterprise", "productivity",
+        "authority", "generation", "organisation", "organization", "goals",
+        "thing", "things", "tasks", "task",
     }
 
     # Allowlist patterns: only inject keywords that look like actual skills
@@ -1296,23 +1301,40 @@ class ResumeCustomizer:
                 ]
                 if missing:
                     self._weave_keywords_into_bullets(tailored, missing, jd_text)
+
+            # ── Populate the categorized SKILLS section (industry standard) ──
+            # The skills section is the #1 ATS keyword vehicle: real checkers
+            # (Jobalytics/Resume Worded) parse it and count hard skills. We list
+            # the JD's REAL skills (taxonomy/vocab terms only — no prose nouns),
+            # prioritised by known-skill then JD frequency, capped to a credible
+            # ~26 (best practice = quality, each keyword 1-3x, not 100).
+            from .ats_scorer import _is_professional_term as _isprof, _is_taxonomy_skill as _istax
+            jd_low = jd_text.lower()
+            skill_pool = [
+                k for k in jd_kw
+                if k.lower() not in self._BUZZWORDS
+                and k.lower() not in self._KEYWORD_BLOCKLIST
+                and len(k) >= 3
+            ]
+            skill_pool = self._dedup_keywords_by_lemma(skill_pool)
+            skill_pool.sort(
+                key=lambda k: (_istax(k.lower()), jd_low.count(k.lower())),
+                reverse=True,
+            )
+            tailored.skills = skill_pool[:26]
         except Exception as e:
             print(f"[weave] {e}")
             self._pending_summary_inject = []
 
-        # 3. Render to DOCX (after weaving)
+        # 3. Render to DOCX (after weaving + skills) — Skills section included
         render_resume_docx(tailored, filepath)
 
-        # 4. Score; if still below 92, also run summary injection for any
-        # keywords that couldn't fit a bullet
+        # 4. Score. Keyword coverage now comes from the categorized Skills
+        # section + contextual bullet weaving (industry standard) — NOT from
+        # appending vague-noun sentences to the summary, which real checkers
+        # penalise as stuffing. The old summary injection is retired.
         score = _score_resume(_read_docx_text(filepath), jd_text, extra_kw=assessed_kw)["ats_score"]
 
-        if score < 92:
-            # Run summary-level injection (closing sentence) for stragglers
-            self._inject_missing_keywords(filepath, jd_text, extra_kw=assessed_kw)
-            doc_text = _read_docx_text(filepath)
-            score = _score_resume(doc_text, jd_text, extra_kw=assessed_kw)["ats_score"]
-
         # 5. Postcondition check
         try:
             self._assert_no_dump_footer(filepath)
@@ -1444,14 +1466,11 @@ class ResumeCustomizer:
     @staticmethod
     def _assert_no_dump_footer(filepath: str) -> None:
         """
-        Postcondition: the generated resume must NOT contain a keyword-dump
-        section. Raises AssertionError if a suspicious pattern is found.
-
-        Caught patterns:
-        - Any paragraph starting with "Additional relevant skills" (legacy footer)
-        - Any paragraph titled "CORE COMPETENCIES" or "SKILLS" — banned by R6
-        - Any paragraph with 10+ bullet-separator characters that isn't a
-          legitimate experience bullet (heuristic: no JD-style phrasing)
+        Postcondition: the generated resume must NOT contain a keyword-DUMP.
+        A clean, categorized SKILLS section is now ALLOWED (industry standard —
+        it's the #1 ATS keyword vehicle). What stays banned is a raw dump: the
+        legacy "Additional relevant skills" footer, or any single line with 15+
+        separators (the keyword-stuffing pattern real checkers penalise).
         """
         from docx import Document as _Doc
         doc = _Doc(filepath)
@@ -1462,14 +1481,16 @@ class ResumeCustomizer:
             if text.lower().startswith("additional relevant skills"):
                 raise AssertionError(
                     f"Dump footer detected: '{text[:80]}'. "
-                    f"Keywords must be woven into bullets/summary, not appended."
+                    f"Keywords must be woven into bullets/skills, not appended as a footer."
                 )
-            upper = text.upper()
-            if upper in {"CORE COMPETENCIES", "CORE COMPETENCIES & SKILLS", "SKILLS",
-                         "TECHNICAL SKILLS", "COMPETENCIES"}:
+            # Raw dump heuristic: one line with 15+ separators (commas/pipes/
+            # bullets). The categorized SKILLS section is safe — each line is
+            # 'Category: a, b, c' with ≤12 items (<15 separators).
+            sep = text.count(",") + text.count("|") + text.count("•")
+            if sep >= 15:
                 raise AssertionError(
-                    f"Banned section header found: '{text}'. "
-                    f"Per project policy R6, the resume has no skills section."
+                    f"Keyword dump detected ({sep} separators): '{text[:80]}…'. "
+                    f"Distribute keywords across categorized lines, not one dump."
                 )
 
     def _extract_experience_sections(self, text: str) -> list[dict]:

src/resume_model.py

@@ -68,6 +68,7 @@ class Resume:
     name: str
     contact: Contact = field(default_factory=Contact)
     summary: str = ""        # 4-6 sentences, opens with recruiter pitch
+    skills: list[str] = field(default_factory=list)  # flat skill list; renderer groups into a categorized SKILLS section
     roles: list[Role] = field(default_factory=list)
     achievements: list[str] = field(default_factory=list)
     education: list[Education] = field(default_factory=list)
@@ -80,6 +81,7 @@ class Resume:
             "name": self.name,
             "contact": asdict(self.contact),
             "summary": self.summary,
+            "skills": list(self.skills),
             "roles": [asdict(r) for r in self.roles],
             "achievements": list(self.achievements),
             "education": [asdict(e) for e in self.education],
@@ -100,6 +102,7 @@ class Resume:
                 website=c.get("website", ""),
             ),
             summary=data.get("summary", ""),
+            skills=[str(s) for s in (data.get("skills") or []) if str(s).strip()],
             roles=[
                 Role(
                     title=r.get("title", ""),
@@ -133,6 +136,12 @@ class Resume:
         if self.summary:
             parts.append("PROFESSIONAL SUMMARY")
             parts.append(self.summary)
+        if self.skills:
+            parts.append("SKILLS")
+            # Emit in chunks of 8 (mirrors the renderer's categorized lines) so
+            # no single line trips the scorer's anti-spam strip (15+ separators).
+            for i in range(0, len(self.skills), 8):
+                parts.append(", ".join(self.skills[i:i + 8]))
         if self.roles:
             parts.append("PROFESSIONAL EXPERIENCE")
             for r in self.roles:

src/resume_renderer.py

@@ -9,8 +9,10 @@ The visual is locked. Every tailored resume looks identical:
 - Bullets: 10.5pt, hanging indent, single line spacing
 - Achievements: 3-5 quantified bullets
 - Education: degree (bold) + institution·dates (italic gray)
+- Skills: categorized SKILLS section (Tools, Methodologies, Domains, Core)
+  placed after the summary — the industry-standard ATS keyword vehicle.
 
-NO Skills/Competencies section anywhere. NO sub-sections.
+NO sub-sections within roles.
 """
 
 from __future__ import annotations
@@ -45,6 +47,7 @@ def render_resume_docx(resume: Resume, filepath: str) -> str:
 
     _write_header(doc, resume)
     _write_summary(doc, resume)
+    _write_skills(doc, resume)
     _write_experience(doc, resume)
     _write_achievements(doc, resume)
     _write_education(doc, resume)
@@ -122,6 +125,108 @@ def _write_summary(doc: Document, resume: Resume) -> None:
         r.font.color.rgb = _BODY_COLOR
 
 
+# Canonical casing for acronyms/brands so the Skills section reads correctly.
+_SKILL_CASE = {
+    "prd": "PRD", "prds": "PRDs", "saas": "SaaS", "api": "API", "apis": "APIs",
+    "crm": "CRM", "ux": "UX", "ui": "UI", "kpi": "KPI", "kpis": "KPIs",
+    "ga4": "GA4", "ai": "AI", "ml": "ML", "nlp": "NLP", "llm": "LLM",
+    "llms": "LLMs", "ocr": "OCR", "qa": "QA", "sql": "SQL", "gtm": "GTM",
+    "okr": "OKR", "okrs": "OKRs", "mvp": "MVP", "roi": "ROI", "cac": "CAC",
+    "ltv": "LTV", "nps": "NPS", "arpu": "ARPU", "b2b": "B2B", "b2c": "B2C",
+    "siem": "SIEM", "soar": "SOAR", "xdr": "XDR", "secops": "SecOps",
+    "devops": "DevOps", "mlops": "MLOps", "plg": "PLG", "sso": "SSO",
+    "fintech": "FinTech", "edtech": "EdTech", "martech": "MarTech",
+    "healthtech": "HealthTech", "ecommerce": "eCommerce", "a/b testing": "A/B Testing",
+    "power bi": "Power BI", "ga": "Google Analytics", "powerbi": "Power BI",
+}
+
+# Skill → category buckets (order = display order). A skill matches a bucket if
+# it appears in that bucket's term set; anything else falls into "Core".
+_TOOLS = {
+    "jira", "confluence", "figma", "notion", "asana", "miro", "trello", "linear",
+    "mixpanel", "amplitude", "ga4", "google analytics", "ga", "metabase",
+    "tableau", "looker", "power bi", "powerbi", "sql", "excel", "spreadsheets",
+    "segment", "hotjar", "salesforce", "hubspot", "webengage", "clevertap",
+    "braze", "slack", "productboard", "airtable", "python",
+}
+_METHODS = {
+    "agile", "scrum", "kanban", "lean", "sprint", "sprint planning", "okrs", "okr",
+    "a/b testing", "experimentation", "experiments", "design thinking",
+    "discovery", "roadmapping", "prioritization", "gtm", "go-to-market",
+    "go-to-market strategy", "hypothesis testing", "user research",
+    "agile methodologies", "backlog", "story mapping", "iteration",
+    "performance tracking", "gap analysis", "competitive analysis",
+    "competitor analysis", "market research", "benchmarking",
+}
+_DOMAINS = {
+    "fintech", "edtech", "healthtech", "martech", "ecommerce", "saas", "b2b",
+    "b2c", "lending", "credit", "insurance", "fraud", "banking", "payments",
+    "logistics", "cybersecurity", "secops", "siem", "soar", "xdr",
+}
+
+
+def _cap_skill(s: str) -> str:
+    k = s.strip().lower()
+    if k in _SKILL_CASE:
+        return _SKILL_CASE[k]
+    if "/" in k:
+        return "/".join(p.capitalize() for p in k.split("/"))
+    return " ".join(w.capitalize() for w in k.split())
+
+
+def _write_skills(doc: Document, resume: Resume) -> None:
+    """Categorized SKILLS section — the industry-standard ATS keyword vehicle.
+
+    Groups the flat skill list into Tools, Methodologies, Domains, and Core
+    Competencies, each rendered as one 'Category: a, b, c' line. Lines are kept
+    short (≤12 items) so they read cleanly and never look like a keyword dump.
+    """
+    if not resume.skills:
+        return
+    # Dedup (case-insensitive), preserve order
+    seen, flat = set(), []
+    for s in resume.skills:
+        k = s.strip().lower()
+        if k and k not in seen:
+            seen.add(k)
+            flat.append(s.strip())
+
+    buckets = {"Tools & Analytics": [], "Methodologies": [], "Domains": [], "Core Competencies": []}
+    for s in flat:
+        k = s.lower()
+        if k in _TOOLS:
+            buckets["Tools & Analytics"].append(s)
+        elif k in _METHODS:
+            buckets["Methodologies"].append(s)
+        elif k in _DOMAINS:
+            buckets["Domains"].append(s)
+        else:
+            buckets["Core Competencies"].append(s)
+
+    # One clean line per non-empty category (cap 12 items so it reads as a real
+    # skills line, never a dump, and the category label never repeats).
+    lines: list[tuple[str, list[str]]] = []
+    for cat, items in buckets.items():
+        if items:
+            lines.append((cat, items[:12]))
+    if not lines:
+        return
+
+    _add_section_header(doc, "SKILLS")
+    for cat, items in lines:
+        p = doc.add_paragraph()
+        p.paragraph_format.space_after = Pt(2)
+        label = p.add_run(f"{cat}: ")
+        label.bold = True
+        label.font.name = "Calibri"
+        label.font.size = Pt(10.5)
+        label.font.color.rgb = _NAME_COLOR
+        body = p.add_run(", ".join(_cap_skill(x) for x in items))
+        body.font.name = "Calibri"
+        body.font.size = Pt(10.5)
+        body.font.color.rgb = _BODY_COLOR
+
+
 def _write_experience(doc: Document, resume: Resume) -> None:
     if not resume.roles:
         return