Writing a skills section you can defend

Asha’s first skills section had 40 items in one line: every language, framework and tool she had ever opened. That is 40 claims for a recruiter to check and 40 places for an interviewer to start, and the rest of her resume showed only 11 of them in use.

This lesson trims such a list to the skills a line of your resume proves, and groups them so that a reader finds a posting’s must-haves in seconds. Two habits that look helpful and are not get their own parts: writing skills in your own spelling instead of the posting’s, and rating yourself with bars, stars or percentages.

Every skill on the list needs a line that shows it

MIT’s careers office makes the point in passing: you may list skills in a Skills section, but naming them in your experience descriptions reinforces them by putting them in context, so if you wrote software, say what language you used. LinkedIn builds the same idea into its profiles: when you add a skill, it asks you to tick where you put it to use. A list is a set of claims, and the lines above it are the evidence.

That gives a rule, which is MySmartCoPilot guidance: a skill stays on the list only when a bullet or a project on the same resume shows it in use. The program applies it to Asha’s 40-skill draft, her five lines of evidence and the terms of the backend posting of the job-description lesson. Press Edit, put your own skills and lines in, and run it:

# Trims a skills section by one rule (MySmartCoPilot guidance): a skill stays only when a line of the resume shows it in
# use. It reads the 40-skill draft of Asha, the invented backend engineer of this track, against her five lines of
# evidence and the terms of the invented Example Freight posting, keeps what a line proves, groups it by kind with the
# posting's terms first, and names the line behind each skill. Press Edit, put your own skills and lines in, and run it.
import re

DRAFT = {
    "Languages": ["Python", "Go", "SQL", "Java", "C++", "JavaScript", "TypeScript", "Bash"],
    "Frameworks and APIs": ["Django", "Flask", "FastAPI", "Spring Boot", "React", "Node.js", "Express", "REST APIs",
                            "Microservices"],
    "Data": ["PostgreSQL", "MySQL", "Redis", "MongoDB", "Kafka", "Elasticsearch", "Cassandra"],
    "Cloud and DevOps": ["Docker", "Kubernetes", "Terraform", "Jenkins", "GitHub Actions", "AWS", "Google Cloud", "Azure",
                         "Ansible"],
    "Tools": ["Git", "Grafana", "Prometheus", "Jira", "Postman", "Linux", "VS Code"],
}
LINES = [
    "Built REST APIs in Python for route lookups and cut their p95 latency from 420 ms to 180 ms with PostgreSQL indexes "
    "and a Redis cache.",
    "Moved 14 services to Docker and Kubernetes through infrastructure-as-code in Terraform, so a deploy takes 9 minutes "
    "instead of 40.",
    "Built a Kafka consumer for 2 million shipment events a day, with idempotent writes and Grafana alerts.",
    "Wrote Python data-quality checks that stopped 37 bad rows a week before they reached dashboards.",
    "Bus pass renewal bot (Python, FastAPI, PostgreSQL): renews a monthly pass in 3 messages instead of a 20-minute "
    "queue; Docker keeps it on one small server.",
]
POSTING = ["Python", "Go", "PostgreSQL", "MySQL", "REST APIs", "Kafka", "Docker", "Kubernetes", "Grafana", "Prometheus",
           "AWS"]
SHOWN_BY = {"SQL": ["PostgreSQL", "MySQL"]}  # a line that uses PostgreSQL shows SQL too


def named(term, line):
    return re.search(rf"(?<![\w+#.-]){re.escape(term)}(?![\w+#-])", line, re.IGNORECASE) is not None


def evidence(skill):
    """The first line that shows the skill in use, or None."""
    for line in LINES:
        if named(skill, line) or any(named(t, line) for t in SHOWN_BY.get(skill, [])):
            return line
    return None


kept, left_off = {}, []
for group, skills in DRAFT.items():
    proven = [s for s in skills if evidence(s)]
    left_off += [s for s in skills if not evidence(s)]
    if proven:
        kept[group] = sorted(proven, key=lambda s: (s not in POSTING, skills.index(s)))
total = sum(len(v) for v in DRAFT.values())
count = sum(len(v) for v in kept.values())
print(f"Draft: {total} skills. Kept: {count}, each shown in use by a line of the resume.")
print()
for group, skills in kept.items():
    print(f"{group}: {', '.join(skills)}")
    for s in skills:
        mark = "posting" if s in POSTING else "       "
        print(f"  {mark}  {s:<11} {evidence(s)[:58]}…")
print()
print(f"Left off, because no line shows them in use ({len(left_off)}):")
print("  " + ", ".join(left_off))
missing = [t for t in POSTING if t in left_off]
print()
print(f"Posting terms with no line behind them: {', '.join(missing)}.")
print("Write the line that shows each one you have really used; leave the others off.")

Draft: 40 skills. Kept: 11, each shown in use by a line of the resume.

Languages: Python, SQL
  posting  Python      Built REST APIs in Python for route lookups and cut their …
           SQL         Built REST APIs in Python for route lookups and cut their …
Frameworks and APIs: REST APIs, FastAPI
  posting  REST APIs   Built REST APIs in Python for route lookups and cut their …
           FastAPI     Bus pass renewal bot (Python, FastAPI, PostgreSQL): renews…
Data: PostgreSQL, Kafka, Redis
  posting  PostgreSQL  Built REST APIs in Python for route lookups and cut their …
  posting  Kafka       Built a Kafka consumer for 2 million shipment events a day…
           Redis       Built REST APIs in Python for route lookups and cut their …
Cloud and DevOps: Docker, Kubernetes, Terraform
  posting  Docker      Moved 14 services to Docker and Kubernetes through infrast…
  posting  Kubernetes  Moved 14 services to Docker and Kubernetes through infrast…
           Terraform   Moved 14 services to Docker and Kubernetes through infrast…
Tools: Grafana
  posting  Grafana     Built a Kafka consumer for 2 million shipment events a day…

Left off, because no line shows them in use (29):
  Go, Java, C++, JavaScript, TypeScript, Bash, Django, Flask, Spring Boot, React, Node.js, Express, Microservices, MySQL, MongoDB, Elasticsearch, Cassandra, Jenkins, GitHub Actions, AWS, Google Cloud, Azure, Ansible, Git, Prometheus, Jira, Postman, Linux, VS Code

Posting terms with no line behind them: Go, MySQL, Prometheus, AWS.
Write the line that shows each one you have really used; leave the others off.

Eleven of the 40 survive, each with the line that proves it. Four of the posting’s terms have no line: Go and MySQL are alternatives the posting offers to Python and PostgreSQL, which she has, while Prometheus and AWS are nice-to-haves she has not used, so they stay off. Git goes as well. She uses it every day, but no line says so, and listing it tells a reader nothing new.

Group the list by kind, with the posting’s terms first

A grouped list lets a reader find one skill in seconds: languages, frameworks and APIs, data, cloud and DevOps, and tools. Inside each group, the posting’s terms come first. In total, MySmartCoPilot suggests 8 to 15 items. A profile is different: LinkedIn allows up to 100 skills, but a resume list that long stops being read. Soft skillssoft skill: A personal or social ability, such as leading, teaching, explaining or working in a team. A resume shows it through what you did with it, in a bullet, rather than by naming it in a list., such as leadership or teamwork, belong in bullets as evidence (“Led a team of four that…”), not in the list as adjectives.

Each skill on a draft ends up in one of four places. Answer three questions about one of yours, and the table marks where it belongs:

In short: first in its group when the posting asks and a line proves it, later when only a line proves it, a new bullet first when you have used it but nothing shows it, and off when you could not talk about it for ten minutes.

Two habits deserve parts of their own. Write a skill in the posting’s spelling when you truly have it, because a search for PostgreSQL does not find Postgres. And leave out bars, stars and percentages: they are drawn or vague, and a reader learns nothing from them.

Writing the posting's terms for the skills you have Pro: opens with a Pro, Premium or Ultimate pass

Bars, stars and percentages: what extraction keeps of a rating Pro: opens with a Pro, Premium or Ultimate pass

Three skills sections, worked: a student, a switcher, a senior engineer Pro: opens with a Pro, Premium or Ultimate pass

Practise: trim and group a student’s skills

Ritu, an invented final-year student, has a draft of 24 items in one group, with ratings. Rewrite it for her internship posting by the rules of this lesson; the sample tests check each rule against the lines of her resume:

# Ritu's draft: one group, with ratings. Rewrite it by the rules of the prompt.
SKILLS = {
    "Skills": [
        "Python 90%", "SQL", "MS Excel", "Power BI 50%", "Tableau", "Pandas", "NumPy", "Matplotlib", "Jupyter",
        "Git", "GitHub", "Statistics", "Java", "C", "HTML", "CSS", "Machine Learning", "Deep Learning", "TensorFlow",
        "MS Word", "Team player", "Leadership", "Communication", "Hard-working",
    ],
}

import re

from skills import SKILLS

LINES = [
    "Wrote SQL queries and a Python script with pandas that cleaned 18,000 rows of canteen sales for a class project.",
    "Built a Microsoft Excel model of hostel electricity use that the warden now updates every month.",
    "Charted four years of placement-cell data with Matplotlib and NumPy in Jupyter notebooks.",
    "Built a Tableau dashboard of library footfall for the student council.",
    "Kept the project's code in Git, with a README a classmate used to rerun the analysis.",
]
MUST_HAVES = ["SQL", "Python", "Microsoft Excel", "Power BI"]
GROUPS = ["Languages", "Frameworks and libraries", "Data and BI", "Cloud and DevOps", "Tools"]


def shown(skill):
    """A line uses the skill, written as the line writes it."""
    return any(re.search(rf"(?<![\w-]){re.escape(skill)}(?![\w-])", line) for line in LINES)


def items():
    return [s for group in SKILLS.values() for s in group]


def test_groups_by_kind():
    """uses only the five group names, and no empty group"""
    assert SKILLS, "SKILLS is empty"
    for group, skills in SKILLS.items():
        assert group in GROUPS, f"{group!r} is not one of the group names"
        assert skills, f"the group {group!r} is empty"


def test_every_skill_shown_by_a_line():
    """keeps only skills that a line of the resume shows, spelled as the line spells them"""
    for skill in items():
        assert shown(skill), f"no line shows {skill!r} as it is written"


def test_no_ratings():
    """lists skills without ratings or percentages"""
    for skill in items():
        assert not re.search(r"\d|%|★|/10", skill), f"{skill!r} carries a rating"


def test_must_haves_she_has_and_only_those():
    """includes every must-have a line shows, and none that no line shows"""
    for must in MUST_HAVES:
        if shown(must):
            assert must in items(), f"the must-have {must!r} is shown by a line but missing"
        else:
            assert must not in items(), f"{must!r} is a must-have, but no line shows it"


def test_must_haves_first_and_length():
    """puts must-haves first in their group, and keeps 8 to 15 items"""
    for group, skills in SKILLS.items():
        flags = [s in MUST_HAVES for s in skills]
        assert flags == sorted(flags, reverse=True), f"in {group!r}, a must-have comes after another skill"
    assert 8 <= len(items()) <= 15, f"{len(items())} items: keep 8 to 15"

Then answer questions on evidence and grouping; the idea you have answered worst so far comes first:

Interview questions

Warm-up (fresher to mid-level): How do you decide which skills go on your resume?

A skill goes on the list only when a line of the resume shows me using it, and when I could talk about it for ten minutes with an example of my own. Then I group the list by kind, put the posting’s terms first in each group, and keep it to about 8 to 15 items. A must-have I do not have stays off, because the interview would expose it; I would rather close the gap first. Soft skills go into bullets as evidence, not into the list.

Three questions of this module’s bank go further:

Key takeaways

• A skill stays on the list only when a bullet or a project on the same resume shows it in use.
• Group the list by kind, put the posting’s terms first in each group, and keep about 8 to 15 items.
• Soft skills belong in bullets as evidence, and a skill you could not discuss for ten minutes stays off.