I spent weeks reading hiring threads, portfolio guides, recruiter-facing articles, Reddit discussions, and academic papers to answer one question: what do people actually look at when they evaluate a GitHub profile?
I expected to find a clear standard. I didn't.
What I found was more useful: most README "best practices" aren't rules — they're signals. And there's a formal framework for understanding why some signals matter and others don't.
I wrote up the full deep-dive with all sources and references. Here's the short version of what I verified.
1. Your README Is a Screening Surface, Not Documentation
People don't start with a deep code review. The first pass is shallow — they're scanning for signs of seriousness. Eye-tracking research shows recruiters spend about 7 seconds on an initial screen. Your README's first job isn't to explain everything. It's to justify continued attention.
2. Tests and CI Are Signals, Not Checkboxes
Tests, CI, .env.example, meaningful commits — these details keep showing up in advice because they compress information. They help a reviewer infer how you work. But here's the caveat: a CI pipeline on a three-file todo app is a weak signal. These things only matter when attached to substantive work.
3. The Clone Problem Is Real, but Misunderstood
The internet loves to say "remove your Netflix clone." The real issue isn't that familiar project shapes are bad — it's that simple clones signal tutorial-following more than independent judgment. The real divide is replication as an endpoint vs. replication as a starting point for something original.
4. Proof Beats Description — Every Time
A live demo, a screenshot, a short GIF, a deployment link, or even a small number of real users. What matters is whether the reader has to imagine the project works, or can see that it does. After I added a deployment link and a 10-second GIF to one of my projects, people stopped asking "what does it do?" and started asking implementation questions.
5. Writing Helps Only When It Extends Real Work
Blog posts don't replace projects. But "I built X, here's what broke, and here's what I learned" is powerful — because it shows how you think. A post-mortem of a real project is hard to fake. Generic "Top 10 tips" pieces are not.
What I'd Actually Do Now
If I were cleaning up a GitHub repo today, I'd focus on five things:
- Explain what the project is in one clear sentence
- Show proof that it works: demo, screenshot, deployment
- Include signals of engineering discipline: tests, CI, setup clarity
- Explain why the project exists, not just what it does
- Add a section showing reflection: trade-offs, challenges, what you'd change
The question that ties it all together:
What uncertainty is this README removing for the person reading it?
The full article goes deeper into the academic research behind these ideas — including signaling theory, eye-tracking studies, and peer-reviewed work on how GitHub profiles are evaluated in hiring.
👉 Read the full deep-dive on Medium
📂 All sources and references are also available on GitHub: github.com/KazKozDev/github-rabbit-hole
What do you think is the stronger signal in a portfolio: a polished clone, or a rough project with real users? I'd love to hear your take in the comments.