GitHub portfolio for AI roles: what reviewers look at
How to set up a GitHub portfolio for AI roles: which repos to pin, what a README needs, how commit history reads, and what to remove.
On this page
A GitHub portfolio for AI roles is judged mostly on its pinned repositories and their READMEs. A reviewer who follows the link from your resume typically looks at what is pinned, opens the most relevant project, reads the README, and skims some code and the commit history. Two to four well-explained projects with a clear evaluation section do more for you than dozens of unexplained repositories.
What do reviewers look at on a GitHub profile?
Reviewers look at a GitHub profile in a predictable order, and most of them stop early. The people who open your profile are usually engineers on the hiring team or interviewers preparing questions, and they have limited time per candidate.
Profile page
Name, short bio and the pinned repositories. Is anything here related to the role?
One repository
The reviewer opens the pinned project with the most relevant name and description.
README
What does the project do, how was it built, and does the author show results?
Code skim
A look at the folder structure and one or two files: is this organised, readable code?
Commit history
A glance at whether the project was built over time by the candidate.
Each step is a chance to keep the reviewer or lose them. If the pinned area shows nothing relevant, the review ends at step one. If the README is empty, the review ends at step three, however good the code is.
Which repositories should you pin?
Pin two to four repositories that you built yourself and that match the role you want. GitHub lets you choose up to six pinned items; filling all six with weak projects dilutes the strong ones.
A good pinned set for an AI role contains:
- One end-to-end project. Data in, model or LLM in the middle, a usable interface or API out, with evaluation.
- One project matching your target track. A retrieval application for a GenAI role, a training and serving pipeline for an ML role, an orchestration or monitoring project for a platform role.
- Optionally, one that shows engineering range. A well-tested library, a tool you actually use, or a real contribution to an open-source project.
Give each pinned repository a clear name and a one-line description, since both show on the profile page. "rag-policy-assistant: question answering over public policy documents with retrieval and an evaluation set" tells the reviewer what to expect. "project-final-2" does not.
For what to build, the guide to AI portfolio projects that get interviews covers project ideas with enough depth to discuss in an interview.
What should the README of an AI project include?
The README of an AI project should include what the project does, how it works, how to run it, how it was evaluated, and what its limits are. The README is the page a reviewer reads, so treat it as the project's cover note.
| README section | What it answers | Length |
|---|---|---|
| Summary | What does the project do, and for whom? | 2 to 3 sentences |
| Approach | What are the main components and why these choices? | A short list or diagram in text |
| How to run | Which commands take a new user from clone to result? | A code block |
| Evaluation | How do you know it works, and how well? | A small table and a paragraph |
| Limits and next steps | Where does it fail, and what would you change? | 3 to 5 lines |
A skeleton to start from:
# Policy Assistant
Answers questions about public policy documents using retrieval and
a language model. Built to learn how retrieval quality affects answers.
## Approach
- Ingestion: splits documents by section, stores embeddings
- Retrieval: vector search, then re-ranking
- Generation: prompt with retrieved passages and citations
## Run it
pip install -r requirements.txt
python ingest.py data/
python app.py
## Evaluation
40 hand-written questions with expected source sections.
Reports retrieval hit rate and answer correctness for each version.
## Limits
Fails on questions that span several documents. Tables are not parsed.The figures and names in the skeleton are placeholders for your own. The evaluation and limits sections are the ones most candidates skip and the ones reviewers remember. Stating where your system fails shows that you tested it. If evaluation is new to you, the guide on how to evaluate an LLM application explains test sets and baselines.
Does commit history matter to reviewers?
Commit history matters as a sign that you built the project yourself over time, not as a count. A reviewer is not grading your activity graph. A history with many small, described commits reads as real work; a single commit titled "initial commit" containing the whole project reads as a copy or an upload.
Raises doubts
- One bulk commit with the entire project
- Messages such as 'update', 'changes', 'final'
- Daily trivial edits made only to colour the activity graph
- Large data files and notebook outputs committed by accident
Builds confidence
- Commits spread over days or weeks as the project grew
- Messages that say what changed: 'Add re-ranking step to retrieval'
- A visible fix after an evaluation result: 'Fix chunk overlap bug found in eval'
- A .gitignore, a requirements file and a sensible folder layout
Do not rewrite history to look busier, and do not worry about gaps. Engineers with full-time jobs have quiet months, and reviewers know that.
What should you remove from your GitHub?
Remove, archive or make private anything that weakens the first impression or should never have been public. Cleaning takes an hour and changes how the whole profile reads.
A removal checklist:
- Secrets. API keys, passwords and tokens in any file or past commit. Revoke the key first, then remove it; deleting the file alone leaves it in history.
- Employer or client code. Anything written for work, including snippets, configurations and internal documents.
- Tutorial copies. Course exercises and follow-along projects identical to thousands of others. Keep them private.
- Empty and abandoned repositories. A name with no content, or a project with only a default README.
- Unexplained forks. Forks you never changed. They crowd the list and suggest activity that is not yours.
- Large committed files. Datasets, model weights and notebook outputs that make a repository slow to open.
How should code and notebooks be organised?
Organise an AI project as code in modules with a short notebook for exploration, not as one long notebook. Production AI work at a Global Capability Centre is software engineering, and a reviewer for those roles looks for the habits of an engineer.
Signals that take little effort:
- A folder layout a newcomer can follow, such as
src/,tests/,data/with a note on where data comes from, andnotebooks/. - A requirements or environment file so the project can be installed.
- A few tests for the parts with real logic, such as chunking, parsing or feature code.
- Configuration in a file or environment variables, not hard-coded paths from your laptop.
- Notebooks that run top to bottom, with outputs cleared or kept small.
You do not need continuous integration, containers and a deployment for every project. One project with these basics done properly is enough to show how you work.
How do you connect GitHub to your resume and LinkedIn?
Connect GitHub to your resume and LinkedIn by linking the profile in the resume header and linking each project directly beside its description. A reviewer should reach the right repository in one click, not search your profile for it.
On the resume, each project entry carries its own link and one line on evaluation, as described in the AI engineer resume guide for GCC roles. On LinkedIn, add your best repository to the Featured section; the guide to a LinkedIn profile for AI engineers covers the rest of the profile.
Then check how the resume and its links read together. The free resume check on The GCC Engineer evaluates a resume for AI roles at GCCs, and the free plan includes 5 resume evaluations, shared with job fit checks.
Whatever you link, be ready to explain every line of it. Interviewers commonly pick a project from the profile and ask why you made each choice.
Key takeaways
- Pin two to four of your own projects; quality and relevance beat a long list.
- The README is the page most reviewers actually read, so it must explain problem, approach, run steps and evaluation.
- An evaluation section is the clearest signal that an AI project is more than a demonstration.
- Commit history should look like real work over time, not one bulk upload or a decorated activity graph.
- Remove or make private tutorial copies, empty repositories, and anything containing secrets or employer code.
Frequently asked questions
Do I need a GitHub profile to get an AI role at a GCC?
A GitHub profile is not a formal requirement for most roles, and many experienced engineers are hired on the strength of their work history. A profile helps most when your paid work has little AI in it or cannot be shown, because it is then the only place a reviewer can see how you build.
Should Kaggle notebooks or competition code go on GitHub?
A competition project can go on GitHub if you turn it into a proper repository: a README explaining your approach and what you learned, clean code instead of a single long notebook, and honest results. A link to your Kaggle profile on the resume is a simpler alternative.
Is it a problem if my repositories have no stars?
No. Stars measure popularity, not quality, and reviewers of a candidate's personal projects do not expect them. A clear README, readable code and an evaluation section tell a reviewer far more than a star count.
Can I upload code I wrote at work?
No, unless your employer has explicitly released it as open source. Code written for an employer or a client belongs to them, and publishing it breaks confidentiality. Rebuild the idea as a separate personal project using public data instead.
Should my AI project have a live demo?
A live demo is useful but optional, and a broken demo link is worse than none. A short screen recording or a few sample inputs and outputs in the README shows the project working without the cost and upkeep of hosting.