Refolk
ReferenceMarket and talent intelligence

The Skill-Evidence Reference: Claimed, Practiced, or Proven by Signal

Look up any public skill trace and state its proficiency tier, decay date, coverage, and the exact way it inflates or shrinks a talent pool count.

21 min readLast reviewed November 21, 2026Read as Markdown

Key takeaways

  • In Refolk's index, 511,813 US profiles list "Machine Learning" as a skill, but only 7,945 also hold a Machine Learning Engineer, Machine Learning Scientist, or Research Scientist title, a 64.4x cut.
  • A self-listed skill supports only the claimed tier because it never expires, and in a 25-profile sample of Refolk's US skill-only ML pool, 5 were CTOs and most of the rest were founders.
  • Code counts as evidence only when it was merged or accepted: in one Hacktoberfest year, only 166,057 of 621,104 opened pull requests were merged, about 26.7%.
  • Credentials decay on a schedule that listed skills do not: AWS certifications are valid for three years, and a PMI holder in Suspended status may not refer to themselves as a certification holder.
  • The threshold sets the pool more than the market does: a one-skill rule yields about 11.4 million people with AI skills worldwide in one analytics firm's data, of whom about 280,000 (2%) are AI engineers.
  • Only 15% to 27% of GitHub accounts list a location, so a code-based pool that counts located accounts alone undercounts by roughly 4 to 7 times.

This is the lookup for deciding which public traces count as evidence that someone has a skill, and at what proficiency tier, before a talent-pool number goes to leadership. It is for strategy and research teams, talent-intelligence analysts, and operators sizing a market. For ten common skill signals, it gives the tier each one supports, how fast it decays, how much of the true pool it covers, and the specific way it inflates or deflates a count.

What do claimed, practiced, and proven mean?

Claimed means the person says they have the skill. Practiced means there is evidence they use it at work. Proven means a third party with a gate accepted the evidence: a maintainer, a peer reviewer, or a credential issuer. I place each person in the highest tier that any one valid signal supports, and I count and report each tier separately.

Published talent-pool studies don't use tiers. They use thresholds, which are minimum rules for who gets counted:

  • LinkedIn's AI talent methodology (published on OECD.AI) counts people who have explicitly added at least two AI engineering skills to their profile and/or are or have been employed in an AI job. It counts AI literacy skills, such as prompt engineering, as a separate group.
  • A labor-market analytics firm's global breakdown counts anyone who holds an AI job title or lists at least one AI skill.
  • Element AI's global talent report required a PhD, target titles, and named tools (Python, plus TensorFlow or Theano). It also built a more advanced subset of people who listed specific frameworks such as torch, caffe, and nltk.

No public study reports what share of a pool is claimed, practiced, or proven. The three-tier scheme is mine, and it has one narrow purpose: two analysts looking at the same person should put them in the same tier for the same reason.

Every row below uses four more terms:

  • Decay: how long a signal stays true after it is recorded.
  • Coverage: the share of people who really have the skill that the signal can see at all.
  • Inflation mode: how the signal adds people who don't belong.
  • Deflation mode: how the signal drops people who do belong.

The three skill-evidence tiers

  1. Claimed
    The person says so: self-listed skills, title keywords, description text, course badges
  2. Practiced
    Evidence of use at work: a specific title plus the skill, descriptions that name frameworks, code in the person's own repos, talks
  3. Proven
    A gatekeeper accepted it: merged code in other people's repos, peer-reviewed bylines, Active credentials verified with the issuer
Each tier is a subset of the one above it, and only the innermost tier rests on a third party's gate.

Why do talent-pool counts for the same skill differ so much?

The threshold and the type of evidence decide how big a skill pool looks, more than the market does. In Refolk's index, adding a title requirement to a skill requirement shrinks the US machine-learning pool by a factor of 64.

FilterUS countShare of skill pool
Skill listed: "Machine Learning"511,813100%
Skill plus ML Engineer, ML Scientist, or Research Scientist title7,9451.55% (derived)
Reduction multiple (derived)64.4x
64.4x
Drop from skill-only to skill-plus-title, US "Machine Learning" profiles
In Refolk's index, 511,813 profiles list the skill, but only 7,945 also hold a machine-learning or research-scientist title.

Most of the people the title filter removes are not hidden practitioners. In a 25-profile sample of the US skill-only pool, 5 held the title Chief Technology Officer and most of the rest were founders. They list machine learning because they buy or manage ML work, not because they do it. That is how a talent-pool count built on self-reported skills ends up overstated.

The published counts show the same pattern across evidence types:

SourceSignalCount
Element AI, first reportConference presenters5,400
Element AI, first reportSelf-reported profilesabout 22,000
Element AI, second reportSelf-reported, PhD-filtered36,524
Labor-market analytics firmAI engineersabout 280,000
Labor-market analytics firmAny AI skill (derived sum)about 11.4 million

How to read that table:

  • Claimed beats proven about 4.1 to 1. Element AI's first report found about 22,000 self-reported specialists but only 5,400 people publishing and presenting at AI conferences.
  • Claimed counts grow faster. The self-reported count rose 66% in one year, from 22,000. Over the same period the conference base widened from 3 to 21 conferences. Re-listing a skill costs nothing, but a byline needs peer review.
  • A one-skill threshold measures literacy. Under the one-skill rule, only 2% of people with AI skills are AI engineers (about 280,000). Another 32% are other tech workers (about 3.6 million), and 66% are in non-tech roles.
  • A two-skill-or-occupation threshold measures something else. Under LinkedIn's rule, 7 of every 1,000 members globally count as AI engineering talent. LinkedIn once grouped AI skills into one category of around 38,000 distinct skills. A one-skill rule over a bundle that broad catches almost anyone who has touched the topic.

The claimed tier also compares badly between countries:

CountryProfiles listing "Machine Learning"
United States511,813
Germany56,895
US to Germany ratio (derived)9.0x

That 9.0x ratio holds at the claimed tier. Nobody has established whether the practiced or proven tiers show the same ratio. Before you quote a country comparison, run the same title cut in both countries. Pulling both cuts from one index keeps the threshold the same across countries. In Refolk, each cut is a single plain-English request, so the claimed and narrowed counts come from the same records.

Skill-signal lookup: tier, decay, and distortion

Merged code in repositories the person doesn't own, peer-reviewed bylines, and Active credentials verified with the issuer are the only signals here that can support the proven tier. Every other signal stops at claimed or practiced. The two tables give each signal's highest tier, how it decays, and which way it distorts a count. The next section has the detail for each one.

Profile and learning signals:

SignalHighest tierDecayDistorts the count by
Self-listed skillClaimedNever expiresInflating: executives, literacy-level listers
Title keywordPracticed, with skillUntil the title changesDeflating: generic titles drop out
Role description textPracticed if frameworks are namedUntil editedInflating: buzzword use
Course completionClaimedNo published expiryInflating: counted as certification
Issuer-verified credentialProven, while ActiveAWS 3 years; Azure, Google annualBoth: stale badges, lookalike lookups

Work-product signals:

SignalHighest tierDecayDistorts the count by
Conference or journal bylineProvenSet by your windowDeflating: misses private labs
Patent inventorshipPracticed (not established)Set by your windowNot established
Merged code in the ecosystemProven, in others' reposSet by your windowInflating, if opened PRs are counted
Package maintainershipPracticed; proven with outside usersFrom the last releaseNot measured publicly
Conference talkPracticedSet by your windowDeflating: narrow coverage

Where each signal sits on proof and coverage

Wide coverageNarrow coverage
Ceiling signals
Self-listed skills and title keywords; report them as claimed, never as supply
Rarely occupied
If a signal seems to land here, re-check its gate before trusting it
Noise
Course badges, endorsements, opened pull requests; leave them out of counts
Floor signals
Bylines, merged code, Active credentials; report as proven and state coverage
Weak proofStrong proof
High-coverage signals give you a ceiling and strong-proof signals give you a floor, and almost nothing gives you both.

Signal entries: what each trace proves and how it lies

Each entry gives what the signal proves, its tier, how it decays, its coverage, how it lies, and the check that catches the lie. Where nobody has published a measurement, the entry says so.

Self-listed skill

  • Proves: the person wants to be found for the skill. Nothing more.
  • Tier: claimed.
  • Decays: never. A skill list on a profile has no expiry, so the claimed tier keeps people who stopped practicing years ago. The median time since a profile was last edited is not publicly established.
  • Coverage: the widest of any signal. In Refolk's index, 511,813 US profiles and 56,895 German profiles list "Machine Learning". How many real practitioners never list the skill is not publicly established.
  • Lies when: founders and executives list the skill as a strategy topic. Generic skills also crowd out specific ones: across nearly 9 million US profiles, only one-fifth of listed skills are specific. Endorsements don't fix this. Simply counting them has shown serious limitations, and one real dataset was estimated to contain 4% to 6% false endorsements.
  • Check: require two or more specific skills from the bundle, or require the occupation test as well.

Title keyword

  • Proves: the person describes their current role as being in the skill area.
  • Tier: practiced when a specific title appears alongside the skill.
  • Decays: stays true until the person changes the title. Stale profiles keep old titles for an unmeasured length of time.
  • Coverage: narrow. In Refolk's index, 7,945 US profiles combine the skill with a machine-learning or research-scientist title, which is 1.55% of the skill pool.
  • Lies when: it shrinks the count. Practitioners with generic titles such as "Software Engineer" fall out.
  • Check: send generic-title people to the code and byline checks instead of dropping them.

Role description text

  • Proves: the person describes their work in the skill's vocabulary.
  • Tier: claimed. It rises to practiced when the text names specific frameworks rather than the umbrella term.
  • Decays: stays true until edited. No one has measured how long that takes.
  • Coverage: not publicly established.
  • Lies when: "AI" or "machine learning" is used as a buzzword. Nobody has published a check that removes keyword stuffing.
  • Check: do what Element AI did. Require named frameworks, as its advanced subset did with torch, caffe, and nltk, and treat umbrella terms as claimed only.

Course completion

  • Proves: the person was exposed to the material.
  • Tier: claimed.
  • Decays: no published expiry schedule.
  • Coverage: not publicly established.
  • Lies when: a course or learning badge gets counted as a certification. Issuers put courses and learning on the same badge platforms as certifications, so a Credly badge is not always a certification. Nobody has published a check that removes bulk course completions.
  • Check: read the badge type before counting anything. Keep course badges out of the credential count, as LinkedIn keeps literacy skills apart from engineering skills.

Issuer-verified credential

  • Proves: the person met the issuer's standard and, if the status is Active, has kept it up. It does not prove current practice.
  • Tier: proven at exam level, but only while the issuer's own route shows it as Active.
  • Decays: every AWS certification is valid for three years, up from an original two, and maintenance through AWS Skill Builder adds a year. A secondary source says Azure and Google renewals typically involve an annual, unproctored online assessment. A PMI credential moves to Suspended and then Expired when continuing-education credits are missing, and a Suspended holder may not refer to themselves as a certification holder.
  • Coverage: not publicly established. PMI holders can opt out of the registry, so a missing entry doesn't mean the credential has lapsed.
  • Lies when: expired Credly badges stay on the earner's account indefinitely, marked as expired. Credly's help pages don't say what a public viewer sees on a revoked badge.
  • Check: use the issuer's own route. For AWS, that is a 16-character validation number at aws.amazon.com/verification, which confirms the credential is authentic. For PMI, the registry shows Active, Suspended, or Expired. For Microsoft, use Microsoft Learn transcript links, since Microsoft ended its Credly partnership. CompTIA uses a verification code, ISC2 uses last name plus member number, and Salesforce Trailhead has its own route. The status vocabularies for those last three aren't established, so record the raw status as shown.

Conference or journal byline

  • Proves: the person produced peer-reviewed work in the skill.
  • Tier: proven.
  • Decays: each byline is dated by its publication, and you choose the window.
  • Coverage: narrow, and it depends on which venues you include. Element AI's first estimate of about 10,000 came from scraping the publication lists of the top AI conferences. Its venue base later widened from 3 to 21 conferences, so changing the venue list changes the count.
  • Lies when: it shrinks the count. Element AI noted that the method leaves out research published by private think tanks and AI labs. Nobody has published a check for padded author lists.
  • Check: publish the venue list alongside the count, and treat byline-only results as a floor.

Patent inventorship

  • Proves: the person is named on an invention in the skill's area. No public study I found grades inventorship as skill evidence or measures its coverage or inflation.
  • Tier: practiced at most, until you have checked it locally.
  • Check: take a small sample of inventors from your pool and read whether the skill you're counting is central to each invention. Promote the signal only if the sample holds up.

Merged code in the skill's ecosystem

  • Proves: a maintainer accepted the person's work in the skill's ecosystem.
  • Tier: proven for code merged or accepted in repositories the person doesn't own. Code in their own repositories is practiced. A pull request that was opened but never merged is claimed.
  • Decays: at the end of whatever window you set. Neither a 90-day nor a 12-month convention for counting code contributions is publicly established.
  • Coverage: good for identity, poor for geography. About 2.3 million of roughly 15 million GitHub accounts with public activity listed a location, and another count puts the share that publish any location string at 27.2%.
  • Lies when: opened pull requests are counted. In one Hacktoberfest year, only 166,057 of 621,104 opened pull requests were merged.
  • Check: count only work that was merged or labeled accepted, in repositories the person doesn't own, inside a window you state.

Package maintainership

  • Proves: the person ships and maintains code in the ecosystem. If people outside their own projects use the package, others depend on their work.
  • Tier: practiced. It becomes proven when outside usage clears a minimum you set and state.
  • Decays: from the date of the last release. No published standard exists.
  • Coverage and inflation: neither has been measured publicly. The risks I would check first are abandoned packages and packages that only the author uses.
  • Check: set a usage minimum, such as a download threshold, plus a window for the most recent release, and write both down.

Conference talk

  • Proves: a program committee chose the person to speak on the topic.
  • Tier: practiced. It becomes proven only when the talk accompanies a peer-reviewed paper.
  • Decays: each talk is dated, and you choose the window.
  • Coverage: narrow. How talks inflate a count has not been measured.
  • Check: keep talks backed by refereed papers separate from all other talks.

How do you size a talent pool by skill, step by step?

Define the skill bundle, pull the claimed pool, and narrow it with title, code, byline, and credential evidence. Then resolve geography and report each tier with its source and decay date. No source says how long each step takes, so plan the time locally.

Sizing a skill pool by evidence tier

  1. Define the skill bundle and threshold
    Write down the specific skills in the bundle and the rule for who counts, such as two or more specific skills or a single skill, before any data is pulled.
  2. Pull the claimed pool from self-listed skills
    Count profiles that meet the threshold on self-listed skills, separately for each geography, and label the result claimed.
  3. Narrow by occupation or title
    Apply specific titles alongside the skill test to form the practiced count, and set generic-title people aside for evidence checks instead of dropping them.
  4. Check code evidence in a stated window
    Count only contributions that were merged or labeled accepted, in repositories the person does not own, inside a window you write down.
  5. Match people against byline lists
    Match people against author lists from a named set of venues, as Element AI did with 21 conferences, and record the venue list.
  6. Verify credentials through the issuer
    Check each credential on the issuer's own route rather than a badge wallet, and record its status and expiry date.
  7. Resolve geography and remove duplicates
    Geocode location fields, merge people who qualified through several signals, and state location coverage as a percentage.
  8. Report tier counts with coverage caveats
    Report claimed, practiced, and proven counts separately, each with its source, coverage, and earliest decay date.

Steps 4 to 6 can run in parallel, because each one promotes people on its own. Step 7 has to come last: the same person can qualify through code, a byline, and a credential, and counting them three times is the easiest way to inflate the proven tier.

Where do skill-evidence counts go wrong?

Most bad counts come from eight failure modes. Each one has a specific check, and running all eight is what separates a defensible number from a headline number.

  1. Executives in the skill row. The false positive is founders and CTOs who list ML as a strategy topic. They dominated Refolk's 25-profile US sample. Check: require the occupation test, or two or more specific skills.
  2. Generic titles in the title row. The false negative is practitioners titled "Software Engineer" or similar. The narrowed US count is just 1.55% of the claimed pool. Check: add code or byline evidence for these people instead of dropping them.
  3. Acronym collision in the credential row. cloudweb2.aws.org belongs to the American Welding Society, not Amazon. It returns a certification number, name, and expiration date for welding credentials, which can look like a valid result. Check: Amazon's route is aws.amazon.com/verification.
  1. Stale status in the credential row. Microsoft badges synced to Credly can wrongly show as expired, and a recently renewed certification can briefly count as expired. A missing PMI registry entry doesn't mean a lapse, because holders can opt out. Check: use the issuer's own route, and treat a missing entry as unverified, not lapsed.
  2. Course badges counted as certifications. Issuers badge courses and learning on the same platforms as certifications. Check: read the badge type before counting it.
  3. Opened pull requests counted as code evidence. In one Hacktoberfest year, only about 26.7% of opened pull requests were merged. Check: count only merged pull requests, in repositories the person doesn't own.

Opened is not merged: one Hacktoberfest year

  1. Pull requests opened
    621,104

    All pull requests made during the event

  2. Not labeled spam or invalid
    611,506

    Derived; 9,598 removed

  3. Merged
    166,057

    About 26.7% of opened

Roughly three in four opened pull requests never merged, so a count of opened pull requests mostly measures attempts.
  1. Location coverage ignored. Counting only accounts that fill in a location undercounts by roughly 4 to 7 times, because only 15% to 27% of accounts do. Check: state the coverage, or infer location the way one open-source geography study did. It located 85% of active contributors (502,415 people) using account information including email suffixes. Report the accuracy of any inference you use.
  2. Byline counts treated as complete. Conference author lists leave out work from private labs and think tanks. Check: present byline counts as a floor, with the venue list attached.

Changing the rules changes the count, even when the people stay the same. Hacktoberfest's spam rate was 4.82% one year (23,299 of 483,127 pull requests) and about 1.5% the next (9,598 of 621,104). The drop came from the rule that counted only merged or accepted pull requests, plus an opt-in rule for repositories that kept 172,599 pull requests out of participating projects. Contributors didn't suddenly behave better. How much a code signal inflates a count depends on the acceptance gate you apply, so name the gate in the report.

Re-listing a skill costs nothing, but a byline needs peer review, so the claimed-to-proven gap widens in every hype cycle.

How do you report tier counts and keep them current?

Report three counts, each with its source, coverage, and earliest decay date, and schedule the next pull for the earliest decay date in the proven tier. A single number without its tier is exactly the overstated count this reference exists to prevent.

Keep one record per qualifying signal, so any count can be traced back to individual people:

Per-person evidence record
person_id:
signal: (one of the ten signals in this reference)
tier_supported: claimed | practiced | proven
evidence: (link or record ID)
observed_on:
decays_on: (credential expiry date, or observed_on plus your stated window)
verified_via: (issuer route, merge record, venue author list, or profile)
gate_passed: merged or accepted | peer reviewed | Active status | none
exclusion_reason: (blank, or the failure mode it tripped)

Write one record per qualifying signal; the person's tier is the highest tier among their records.

Then roll the records up into a block leadership can read:

Tier count summary for leadership
SKILL POOL: <skill>    GEOGRAPHY: <country or metro>    AS OF: <pull date>
Threshold: <n> specific skills from <bundle list>, plus title test <title list>

CLAIMED    <count>   Source: self-listed skills          Decay: none (no expiry)
PRACTICED  <count>   Source: skill + specific title       Decay: until title changes
PROVEN     <count>   Source: merged code (<window>), bylines (<venue list>), Active credentials (issuer routes)
                     Earliest decay date: <date>

Coverage: location filled for <x>% of code accounts; <method> used to infer the rest, accuracy <y>%
Excluded: course badges, endorsements, opened-but-unmerged pull requests
Set aside: <count> generic-title profiles checked against code and bylines, <count> promoted
Next re-pull: <earliest proven-tier decay date>

Fill in one block per geography and never collapse the three tiers into one number.

Decay rules change over time, so don't hard-code them. AWS changed certification validity once already, from two years to three. On every re-pull, re-read each issuer's renewal policy rather than reusing last quarter's expiry logic. Also re-check whether old badge locations still resolve: whether Microsoft badges claimed on Credly before the move are still visible is not established. Re-running the same plain-English requests in Refolk on the re-pull date keeps the threshold identical between periods, so any movement in the counts reflects the market and not a change in your filters.

Before the count goes to leadership

  • The skill bundle and threshold were written down before any data was pulled.
  • The claimed, practiced, and proven counts are each reported, with none of them left out.
  • A sample of the skill-only pool was reviewed, and the share of founders and executives is stated.
  • Generic-title profiles were checked against code and byline evidence, not dropped.
  • Every code-based proven count includes only merged or accepted work in repositories the person does not own, inside a stated window.
  • Every counted credential shows Active on the issuer's own route, with an expiry date recorded.
  • AWS credentials were checked at aws.amazon.com/verification and not on the welding society's lookup.
  • Course and learning badges are excluded from the credential count.
  • The byline count lists its venues and is labeled as a floor.
  • Location coverage is stated as a percentage, and any inference method is reported with its accuracy.
  • People who qualified through several signals appear once.
  • The next re-pull date equals the earliest decay date in the proven tier.

Questions practitioners ask

How reliable are self-reported skills for sizing a talent pool?

Self-reported skills are reliable only as a ceiling, never as a measure of supply. Nobody has published a match rate between listed skills and skills verified on the job, and a study of nearly 9 million US profiles found no objective benchmark for self-reported skills. In Refolk's index, adding a specific title to the "Machine Learning" skill cuts the US pool from 511,813 to 7,945. Report the skill-only number as the claimed tier and label it that way.

Does a job title prove someone has a skill?

A specific title paired with the skill supports the practiced tier, not proven. Titles are self-described and stay put until the person edits them. They also deflate counts, because practitioners with generic titles such as "Software Engineer" fall out of a title filter. Instead of dropping those people, route them to code and byline checks, where merged contributions or peer-reviewed papers can place them in the proven tier.

Should an expired certification count toward a talent pool?

No. Count a credential only when the issuer's own verification route shows it as Active. Expired Credly badges stay on the earner's account indefinitely with an expired marker, and a PMI holder in Suspended status may not refer to themselves as a certification holder. Keep expired credentials as history if they are useful, but out of the proven tier. A missing registry entry is not proof of a lapse, because PMI holders can opt out.

What time window should I use for counting code contributions?

No published standard sets the window, so choose one and state it next to the count. Neither a 90-day nor a 12-month convention for counting code contributions is publicly established. Whatever window you pick, count only pull requests that were merged or labeled accepted, in repositories the person does not own. That window then becomes the decay date for everyone in the proven tier who qualified on code.

Why do published AI talent counts differ by so much?

They use different thresholds and different evidence. A one-skill rule produces about 11.4 million people with AI skills worldwide in one analytics firm's data, and only about 280,000 of them are AI engineers. LinkedIn's two-skill-or-occupation rule yields 7 in every 1,000 members. Element AI's first report found about 22,000 self-reported specialists but only 5,400 conference presenters. Compare counts only after you have matched their thresholds and tiers.

How do I handle people with no location on their profile?

State the coverage instead of treating the located accounts as the whole pool. Only 15% to 27% of GitHub accounts list a location, so counting located accounts alone undercounts by roughly 4 to 7 times. One study located 85% of active contributors by adding email-suffix inference to the location field. If you infer location that way, report the method and its accuracy alongside the count.

Try it on the search you came here for

Stop building boolean strings. Just describe the person.

Type one sentence. I plan the search, read GitHub, public LinkedIn and Crunchbase records, and the open web as it is right now, and hand back a ranked list with the reason next to every name.

  1. 01Describe them

    One plain sentence. Role, city, stack, stage, whatever matters to you.

  2. 02I read the web live

    GitHub, public LinkedIn and Crunchbase records, the open web. Not a database that went stale last quarter.

  3. 03You read the shortlist

    Ranked, with the reasoning under every name. Open a profile, ask a follow-up, narrow it down.

  • No boolean, no filters, no seat to buy. One box.
  • Read at search time, so a profile updated yesterday counts today.
  • Every step visible as it runs, every name with its reason.

500 free credits on sign-up. No card, no demo call. See real searches.

Read next