Refolk
StandardPositioning and materials

The GitHub Profile Standard, Seven Checks to Link, Fix, or Drop

Grade your GitHub profile on seven pass-or-fail criteria, reach the verdict a second reviewer would, and clear each Fix with a documented step before you send.

21 min readLast reviewed November 19, 2026Read as Markdown

Key takeaways

  • A GitHub link earns its place on a resume only when seven criteria pass: identity match, pinned set, README run test, commit history shape, secret and employer-code exposure, private-contribution setting, and AI-assist honesty.
  • In Refolk's index, only 213 US Software Engineer profiles mention open source in the headline, against 352,625 at entry level alone, so most reviewers judge candidates on pinned personal projects, not upstream work.
  • The widely repeated claim that 87% of recruiters check GitHub has no named primary source, so the case for linking rests on what the profile shows, not on a percentage.
  • A committed credential passes this standard only when it has been revoked and rotated, because GitHub documents that sensitive data cannot be removed from other users' clones or forks.
  • An empty contribution graph is not grounds for a Drop until three commits per pinned repo have been checked with .patch, because commits under a generic or removed email silently vanish from the graph.
  • GitHub allows six pins, repos and gists combined, but three to five pins that each run from their README for a second person beat six that do not.

This is a pre-send gate for engineers about to put a GitHub link on a resume or application. It grades the profile on seven pass-or-fail criteria, using the view a hiring manager actually gets, and ends in one of three verdicts: Link, Fix, or Drop. It is written so two reviewers grading the same profile reach the same verdict, and every Fix comes with the documented step that clears it.

Link means all seven criteria pass and the URL goes on the resume as it is. Fix means at least one criterion fails but you can finish the documented fix before you send. Drop means a criterion still fails when you send, so the link comes off this application.

The verdict is mechanical on purpose. Each criterion is binary, so reviewers do not weigh one against another, and Fix is never a way to put something off. If the fix is not done by the send deadline, the verdict falls to Drop for that application and you regrade before the next one.

VerdictConditionWhat you do
LinkAll seven criteria passSend with the URL
FixOne or more fail, fix done before sendClear it, regrade, then send
DropAny criterion still failing at sendRemove the URL, regrade later

Two failures are rarely fixable inside a normal send window, so expect them to produce a Drop:

  • Former-employer code is public on the account. Removing it is quick. Confirming that nothing derived from it is still public is not.
  • No pin passes both the README run test and AI-assist honesty. Then there is nothing to show yet, and a linked profile only gives a reviewer questions.

Should you put GitHub on your resume? What the evidence supports

Put the link on only when the profile passes this standard. No public survey I could trace establishes how many recruiters open GitHub links, so the case for linking rests on what the profile shows, not on a percentage.

This matters because the pages ranking for "what recruiters look for on github profile" lean on statistics that copy each other. The figures get repeated so often that they look verified. Here is the status of the ones that come up most:

ClaimWhere it appearsNamed primary source found?
87% of recruiters check GitHubSeveral tip pages, no sample or methodNo
83% of hiring managers trust GitHub over resumesA recruiter-sourcing blog, citing a vendor surveyNot located
60 to 80% at least glanceAn AI hiring blog citing "industry surveys"No
70% check before outreachA tutorial siteNo
10.8%No page retrievedNot located

One page ranking for these queries says plainly that it found no named survey measuring how many recruiters check GitHub. That is the honest position. If you see a number in this space, look for the sample size and the survey's name before you let it drive a decision.

What Refolk's index shows about who signals open source

In Refolk's index of professional profiles, very few US software engineers lead with open-source work. That means most profiles get judged on personal projects, and the pinned set carries the weight.

213
US "Software Engineer" profiles with "open source" in the headline
In Refolk's index, against 352,625 entry-level US Software Engineer profiles alone, about 0.06%.
MeasureEntry-level set"Open source" in headline (any seniority)
US "Software Engineer" profiles352,625213
Top employer in a 25-profile sampleGoogle, 4 of 25Google, 2 of 25
Top employer's share of sample16%8%
Other sampled employersn/aOpenTelemetry, Docker, Inc, solo.io, Zilliz

What this proves: upstream open-source identity is a rare signal, and where it appears it clusters around infrastructure projects. What it does not prove is that reviewers ignore GitHub. It only tells you where they are likely to look. For most candidates the reviewer opens the profile, sees the pins, and judges whatever is there. A 25-profile sample is small, so read the employer rows as an illustration, not a ranking.

Which GitHub profile rules do the criteria depend on?

Five documented GitHub rules decide what a reviewer can see: the pin limit, which repos can be pinned, how commits get attributed, how private activity shows, and how secret scanning works. Every criterion below depends on one of them.

SurfaceLimit or rule
Pins6 items, repos and gists combined
Pinnable repoOwned, or contributed to in the last year; forks you don't own excluded
Contribution attributionCommit email linked to the account, or the noreply address
Private activityOff by default; anonymized counts only when on
Secret scanningFree and automatic on public repos

Some details the table leaves out:

  • Pins replace the default. Once you pin anything, the Pinned section replaces the Popular repositories section. If you pin nothing, GitHub decides what a reviewer sees first.
  • Generic emails never link. GitHub's docs say an address like jane@computer.local cannot be added to an account, so commits authored with it will not appear on your graph.
  • Removing an old email erases history. If you delete a former commit email from your account, those historical contributions no longer appear on the graph.
  • The profile README is a convention. The rule that a repo named exactly like your username renders as your profile README comes from a secondary source, not GitHub's docs. Confirm it on your own account in the logged-out view.
  • The signed-out view is only partly documented. GitHub says visitors see only public contributions by default, and people outside a single sign-on (SSO) organization see anonymized activity. I found no doc that compares the signed-out and signed-in views side by side, which is why this standard grades from your own logged-out screenshots.

The seven criteria, stated as pass or fail

Each criterion below gives you four things: the pass condition, what a pass proves, how a pass can mislead, and the documented step that clears a fail. Grade them in order. The cheap ones come first, and a failure early on often explains a failure later.

1. Identity match to the resume

  • Pass when: the profile name, bio, location, and stated employer match the resume you are sending, with zero mismatches.
  • Proves: the reviewer is looking at the same person the resume describes.
  • Lies when: you grade it signed in, or the bio names an employer the resume dropped, or the reverse.
  • Fix: edit the profile fields to match the resume, then retake the logged-out screenshot.

If Refolk wrote your resume from your own history, that resume is your reference sheet. Compare the profile against it field by field, rather than against your memory of what you wrote.

2. Pinned set

  • Pass when: three to five items are pinned, none more than six, each relevant to the roles you are applying for, and each passes criteria 3, 4, and 7.
  • Proves: you chose what the reviewer sees first, and every item can stand up to a click.
  • Lies when: the pins look strong but one of them fails the README run test. Reviewers who click through remember the one that broke.
  • Fix: unpin anything that fails, and pin repos you own or contributed to in the last year. You cannot pin a fork you don't own, because commits to forks don't count as contributions.

On which repositories to pin for job applications, one practitioner source recommends three to five, and I agree. Fewer pins means fewer cold READMEs for a second person to test. Refolk tailors your resume to each posting and scores how well you fit, and the same postings tell you which projects should lead.

3. README run test

  • Pass when: someone other than you follows the README cold, with no help, and the project runs or the demo link works.
  • Proves: the project exists as described and someone can reproduce it without you there.
  • Lies when: you run it yourself. Your machine already has the dependencies, environment variables, and steps you forgot to write down.
  • Fix: for each step the tester got stuck on, add the missing step to the README. Then hand it to the tester again.

This is the real meaning of "github readme for hiring managers": a reviewer cares less about badges than about whether the instructions work. Budget 15 to 30 minutes per repo.

4. Commit history shape and attribution

  • Pass when: commits in every pinned repo are attributed to your account, and the history shows the work being built rather than arriving all at once.
  • Proves: the graph and the history are actually yours.
  • Lies when: the graph looks empty because the commits were made under a generic or removed email. That produces a false Drop.
  • Fix: append .patch to a commit URL to see the email used. GitHub's docs say "You can check the email address used for a commit by adding .patch to the end of a commit URL." If the address isn't linked, add it to your account if GitHub allows it. If you removed it earlier, adding it back is the route to check.

5. Secret and employer-code exposure

  • Pass when: every public repo on the account, pinned or not, has zero open secret scanning alerts, a manual grep finds no keys, every credential ever committed has been revoked and rotated, and no code written for or derived from a former employer is public.
  • Proves: clicking the link creates no security or legal risk for you or a past employer.
  • Lies when: you treat "push protection is on" as proof. See the failure modes section.
  • Fix for secrets: revoke and rotate first, then rewrite history with git-filter-repo --sensitive-data-removal, which is the tool GitHub documents. The git-filter-repo manual says it is "important that you revoke and rotate that credential first."
  • Fix for employer code: take the repo private or delete it, and take it off your pins. Do not just rename things.

The general rule is clear: "Generally, an employer owns all rights in software code created by its employee in the scope of their employment." I did not retrieve real clause text from employment IP or confidentiality agreements, so read your own agreement, and ask a lawyer if a repo is borderline. The public record shows employers enforce this. Twitter sent GitHub a DMCA takedown notice against a repo named "PublicSpace" and then sought a subpoena to identify who posted it. IBM sent a DMCA notice against OpenLava, a project tied to former Platform Computing employees who founded Teraproc, and the notice sits in GitHub's public DMCA repository.

6. Private-contribution setting

  • Pass when: the setting is a deliberate choice, and the resume never cites the contribution graph as evidence of a skill.
  • Proves: you know what the reviewer sees and you are not counting on it.
  • Lies when: you switch it on to fill the graph. The squares become anonymized counts that a reviewer cannot verify.
  • Fix: decide on or off, retake the logged-out screenshot, and remove any resume claim that depends on the graph.

On whether to include private contributions on your GitHub profile: GitHub keeps them off by default, and turning them on shows activity without any detail. An older GitHub doc says outsiders see the number of private contributions you made on a given day. It is honest either way. It just isn't evidence.

7. AI-assist honesty

  • Pass when: every pin either shows incremental history or carries a written note on where AI helped and where you intervened, and you can explain the architecture in a screen-share without notes.
  • Proves: you own the design decisions, whatever tools wrote the lines.
  • Lies when: a legitimate squash-merge import looks like a dump (a false fail), or a tidy history hides code you can't explain (a false pass).
  • Fix: add the note below, or unpin the repo until you can explain it.

The signs practitioners name are specific. One source lists "a single commit containing a finished project, a generic README with no specific details, unedited boilerplate." Another names "structure and comments that scream copy-paste." The danger shows up live rather than on the page. A mentoring platform, MentorCruise, reports candidates "who built portfolio projects with AI assistance but couldn't explain the architecture in a screen-share." So the criterion is whether you can explain the code, not whether you used AI.

AI-assist honesty, per pinned repo

Can explain it liveCannot explain it live
Explainable import
Fix with a note saying where the code came from and why it landed as one commit
Pin it
Passes as long as the README run test also passes
Unpin it
Drop from the pinned set until you rebuild it or can walk through it
Hidden gap
Fix by studying the design until you can explain it, or unpin
One bulk commitIncremental history
Whether you can explain the code decides the verdict, and the history shape only decides how much you need to write down.
AI-use note for a pinned repo README
## How this was built
- Built: <month range>, <solo or with whom>.
- Where AI helped: <scaffolding, tests, a named module, a named refactor>.
- Where I intervened: <what I rewrote, rejected, or designed myself, and why>.
- History note: <if the first commit is a bulk import, where the code lived before and why it landed as one commit>.
- The decision I would walk through in a screen-share: <one design trade-off and the alternative I rejected>.

Replace each angle-bracket item with specifics; a generic note fails the same test as a generic README.

How to grade your profile before you send, step by step

Run these eight steps in order and write the result of each one on the grading sheet. They take roughly an hour for a profile with three pins, plus the time a second person spends on the README tests. GitHub doesn't document a single canonical order. This order puts the free, fast checks ahead of the slow ones and does the logged-out view first, because every other step depends on it.

The pre-send grading procedure

  1. Open the profile signed out
    In a logged-out incognito window, screenshot the header, profile README, pins, and contribution graph. Grade only from these.
  2. Match identity to the resume
    Compare name, bio, location, and employer against the resume you are sending. Done at zero mismatches.
  3. Verify commit email attribution
    Append .patch to three commit URLs per pinned repo and confirm each email is linked to your account or is the noreply address.
  4. Sweep for secrets and employer code
    Check secret scanning alerts on every public repo, grep for keys and former-employer names, and compare repo creation dates with your departure dates.
  5. Choose three to five pins
    Pick items that match your target postings, never more than six, and pin only those that pass the next two steps.
  6. Run the README test with a second person
    Someone else follows each pinned README cold. Done when the project runs or the demo link works.
  7. Check history shape and add AI-use notes
    Flag single bulk commits, add the AI-use note, and confirm you can explain the architecture live, or unpin.
  8. Set private contributions and regrade
    Decide the setting deliberately, reload the logged-out view, regrade all seven criteria, and write down the verdict.

Step timings from practitioner sources: about 2 minutes for the logged-out view, 5 for identity, 10 for attribution, 15 to 60 for the secret and employer sweep, 10 for choosing pins, and 15 to 30 per repo for the README run test. The sweep has the widest range because it depends on how many public repos the account holds, and it covers all of them, not just the pins.

Use one sheet per profile per grading. Two reviewers each fill in their own sheet from the same screenshots. If they disagree, the evidence column shows which criterion they read differently.

Profile grading sheet
Profile URL: github.com/<username>
Graded by: <name>        Date: <date>        View: logged out, incognito
Resume version compared: <file name>

1 Identity match ............ PASS / FAIL   Evidence:
2 Pinned set (3 to 5) ....... PASS / FAIL   Evidence:
3 README run test ........... PASS / FAIL   Tester:          Repos run:
4 History and attribution ... PASS / FAIL   .patch emails checked:
5 Secrets and employer code . PASS / FAIL   Open alerts:     Rotated:     Employer repos:
6 Private contributions ..... PASS / FAIL   Setting:         Resume cites graph? Y / N
7 AI-assist honesty ......... PASS / FAIL   Notes added:     Explained live? Y / N

Verdict: LINK / FIX / DROP
Fix items, documented step, and done-by date:
Send deadline:
If any fix is not done by the send deadline, verdict is DROP for this application.

One sheet per grading; keep the screenshots with it so a second reviewer grades the same view.

Where this standard goes wrong: false passes and false drops

Most grading errors come from trusting a signal that only looks like evidence. Examples: a signed-in view, a push-protection badge, a deleted file, an empty graph, a busy graph. Each failure mode below gives the trap and the check that catches it.

Identity match: the signed-in false pass

Grading while signed in shows you your own view, not the reviewer's, so a mismatch or missing pin can slip through. The check is the rule already stated: grade only from logged-out screenshots.

Attribution: the empty-graph false drop

If commits were made under a generic address, or under an email you later removed, the real work vanishes from the graph and the profile reads as abandoned. A Drop based on an empty graph is not valid until you have checked three commits per pinned repo with .patch. This is the false Drop I see most often, and it is a settings problem, not a missing-work problem.

Secrets: treating push protection as proof

Push protection is not an audit of what is already in your repos. Four reasons:

  • It covers supported patterns only. A credential format GitHub doesn't detect passes straight through. Check GitHub's supported secret scanning patterns page, which changes as detectors are added.
  • It can be bypassed. GitHub says that even with push protection on, "you have the choice to bypass the block."
  • It was not applied retroactively. GitHub's changelog dated 11 March 2024 turned on secret scanning and push protection by default for new personal public repos, and says "existing public repositories are not affected."
  • GitHub's own docs disagree. One repository-settings page says push protection is not enabled by default even for public repos, and a user-level page says push protection for users is on by default for public repos. Don't settle the conflict from documentation. Open each repo's settings and look.

Secret fix order: removed but not rotated

Rewriting history without rotating the secret is the most expensive mistake in this standard. GitHub documents that "you cannot remove sensitive data from other users' clones or forks of your repository," so a scrubbed history can leave a live key in someone else's copy. Some guides tell you to rotate after cleaning. GitHub's docs and the git-filter-repo manual say to rotate first, and I follow them. How long a removed commit stays reachable on GitHub is not established in the sources I found, which is one more reason the pass condition is "rotated", not "removed".

Clearing a committed credential

  1. Revoke and rotate
    Kill the exposed credential and issue a new one before touching history
  2. Rewrite history
    Run git-filter-repo with --sensitive-data-removal on the affected repo
  3. Recheck alerts
    Confirm zero open secret scanning alerts and rerun the manual grep
  4. Accept the residue
    Clones and forks may keep the old commit, so the dead credential is the protection
  5. Record the pass
    Mark criterion 5 as rotated on the grading sheet, with the date
Rotation comes first because it is the only step that also neutralizes copies you cannot reach.

Employer code: renamed is still derived

Renaming modules doesn't change where code came from. The OpenLava dispute shows what happens when code tied to a former employer turns up in a project run by former employees. Two questions catch it. Does any public repo predate your departure from an employer? Does any repo share module names, structure, or internal terms with a past employer's codebase? If either answer is yes, treat it as failing until you can show it isn't derived.

AI honesty: the squash-merge false fail

A legitimate import, such as code moved from a private repo or squashed from a long branch, looks just like a one-commit AI dump. Don't fail a repo on commit count alone. Look for the explanatory note, and if it's missing, the fix is to write it, not to unpin. The opposite error is a false pass: incremental history with code you can't explain. The screen-share test is the only check that catches that one.

Private contributions: activity mistaken for evidence

Turning on private contributions fills the graph with anonymized squares. A reviewer sees that you were active but can't see what you did. If the resume or cover letter points at the graph as proof of a skill, the claim falls apart as soon as someone asks what those squares were.

A link you would have to explain away in the interview is worse than no link at all.

Keeping the verdict current after you send

A Link verdict holds only until something on the profile changes. Regrade whenever you change the resume, add or remove a pin, rotate a commit email, leave an employer, or create a public repo. The full procedure takes about an hour. A regrade after one change usually means rerunning only the steps that change touches, plus the logged-out screenshots.

Practical rules for staying current:

  • Regrade the identity match whenever the resume changes. That is when mismatches appear. Refolk keeps your resume versions tied to the postings they were tailored for, so you can see which version you're comparing against.
  • Rerun the README test after dependency changes. A project that ran six months ago can fail cold today.
  • Sweep secrets on every new public repo. Push protection helps going forward but doesn't replace the manual grep.
  • Keep the grading sheet with the application record. If a reviewer raises something from your profile, you'll know which view they saw.

Before the GitHub link goes on the resume

  • I graded from screenshots taken in a logged-out incognito or private window.
  • Profile name, bio, location, and employer match the resume I am sending, with zero mismatches.
  • Three commits per pinned repo show, via .patch, an email linked to my account or the noreply address.
  • Every public repo has zero open secret scanning alerts, and a manual grep found no keys.
  • Every credential ever committed has been revoked and rotated, not only deleted from history.
  • No public repo contains code written for, or derived from, a former employer.
  • I have three to five pins, and each one ran from its README for a second person or has a working demo link.
  • Every pin shows incremental history or carries a note on where AI helped and where I intervened.
  • I can explain the architecture of every pin in a screen-share without notes.
  • The private-contributions setting is a deliberate choice, and nothing in my materials cites the graph as evidence.
  • The verdict is written down as Link, Fix with a dated fix, or Drop for this application.

If the verdict is Drop, the application isn't weaker for leaving the link off. It's weaker for including a profile that raises questions you would have to answer live. Fix what you can, regrade, and add the link back on the next application that clears all seven criteria.

Questions job seekers ask

Should I put GitHub on my resume if my profile is mostly empty?

Not until you have checked why it looks empty. Commits made under a generic email, or an email you later removed from your account, do not appear on the graph, so real work can vanish. Run the .patch check on a few commits first. If the work is genuinely absent and no pin passes the README run test, leave the link off this application and regrade once you have one project that runs.

Which repositories should I pin for job applications?

Pin three to five repos that match the roles you are applying for, each of which runs from its README for someone who has never seen it. GitHub allows six items, repos and gists combined, and you can only pin repos you own or contributed to in the last year. Pinning replaces the Popular repositories section, so an unpinned profile shows whatever GitHub picks.

Should I include private contributions on my GitHub profile?

Turn it on only if you understand what it shows: anonymized counts, not the work. Private contributions are off by default, and when enabled the public sees activity squares with no repo names or code. That can make a sparse graph look busy, but a reviewer cannot verify any of it, so never cite the graph on your resume as evidence of a skill.

Do recruiters actually look at GitHub profiles?

Some do, but no one has published a traceable number. The figures repeated across tip pages, such as 87% or 70%, have no named survey, sample, or method that I could locate. Treat the link as something a reviewer might open at any point in the process, and make sure that whatever they find either helps you or is not linked.

I committed an API key years ago. Is deleting the file enough?

No. Deleting the file leaves the key in history, and even a full history rewrite cannot reach other users' clones or forks. Revoke and rotate the credential first, which makes every copy useless, then rewrite history with git-filter-repo using its sensitive-data-removal option. The pass criterion in this standard is rotated, not removed.

Can I pin projects I built with AI help?

Yes, if the history or a written note shows where AI helped and where you intervened, and you can explain the architecture live. The documented risk is candidates who could not explain AI-assisted portfolio code in a screen-share. A single commit containing a finished project with a generic README reads as an unreviewed dump, so add the note or unpin it.

Put this to work

Paste your career in once. Every application after that is written for you.

Drop a resume or a LinkedIn URL. I rank the live openings against it, rewrite the resume and write a cover letter for the best of them, and fill in the employer's form when you press the button. You read, you decide what goes out.

  1. 01Drop your resume

    A PDF or a LinkedIn URL. About a minute, once.

  2. 02I rank the openings

    Every weekday morning, the live catalog scored against your history. Up to 20 worth your time, not two hundred links.

  3. 03Each one is written up

    Resume rewritten for the posting, a cover letter, a fit score. Press send, or let me fill in the form.

  • New matches ranked and written before you are up.
  • Every bullet stays inside what your history supports. Nothing invented.
  • Queued, submitted, interviewing, offer: one screen, not a spreadsheet.

Free, no card. Up to 25 applications sent a week, and nothing is sent until you say so.

Read next