Show Your Work: The AI Engineer Proof-of-Work Portfolio

What you need to know

• As of 2026, recruiters and hiring managers ask for links — GitHub, live demos, deployed apps — before they read a CV. Titles and years of experience matter less than demonstrated shipping.
• A recruiter spends under ten seconds on a CV but engages roughly 80% more with a GitHub project that has runnable code or a live demo. The link is the interview's first round.
• Build fewer projects and go deeper. Three to four well-documented pieces beat ten shallow clones, because hiring managers scan for production signals, not a list of tools.
• Anchor the portfolio with a retrieval-augmented generation (RAG) project — RAG is the most in-demand AI engineering skill as of 2026.
• Document each project around the problem, your approach, the metrics, the deployment, and what broke — in that order.
• Make the work findable: a repo, a live demo, and a single profile page that ties them together. An AI Tech Connect Verified Builder profile is that page — and it is free while early Founding Builder spots are open.

Why proof-of-work beats the CV in 2026

The hiring conversation for AI engineers has quietly inverted. A few years ago, a candidate sent a CV, a recruiter screened it for keywords and prestige, and only later — if at all — did anyone look at the actual code. As of 2026, the order has flipped. The first thing a hiring manager at a funded AI team asks for is a link: a GitHub repository, a deployed application, a live demo they can click. The CV, if it gets read at all, is read second — as confirmation, not as the primary screen.

This is not a stylistic preference. It is a rational response to a market where claims are cheap and proof is scarce. Anyone can write "built production RAG systems" on a CV. Far fewer can hand over a repository where the retrieval pipeline is visible, the evaluation harness runs, and a hosted demo answers questions correctly on a dataset you have never seen. The link collapses the gap between what a candidate claims and what they can actually do, and it does so in seconds. That is why, across both the Indian and UK markets, titles and years of experience have become weaker signals than demonstrated shipping. A self-taught engineer in Pune with three deployed projects increasingly out-competes a credentialed candidate in London whose work nobody can see.

For builders, the practical implication is liberating and slightly uncomfortable at the same time. Liberating, because you no longer need a famous employer or a decade of tenure to be taken seriously — you need evidence. Uncomfortable, because the evidence has to actually exist, be public, and stand up to scrutiny. The rest of this guide is about producing that evidence efficiently: building the right work, documenting it so it gets read, and putting it somewhere the people hiring will find it. For the hiring manager's side of the same coin, our guide on getting your AI projects discovered without cold applying covers the visibility half of the equation.

The anatomy of a portfolio that gets read

Start with the most sobering number in AI hiring. A recruiter spends under ten seconds on a CV. Ten seconds is not enough time to read a paragraph, let alone evaluate a career. But the same recruiters and hiring managers engage roughly 80% more with a GitHub project that features runnable code or a live demo. The asymmetry is the whole game: the CV is a low-engagement artefact competing against hundreds of identical ones, while a working link is a high-engagement artefact that almost nobody else provides well.

What are reviewers actually looking for in those high-engagement minutes? Not novelty, and not your tech-stack list. They scan for production signals — the small, unglamorous evidence that you have shipped working software end to end. Specifically:

• Error and failure handling. Does the code anticipate the model returning malformed output, the API timing out, the retrieval step returning nothing? Graceful degradation is a senior signal even in a junior portfolio.
• Data structuring. How is input cleaned, chunked, validated, and stored? Sloppy data handling is the most common tell that a project never touched real users.
• System integration. Does the project connect to something — a database, a vector store, an external API, a front end — or is it a notebook that runs once and stops?
• Evidence of shipping. Is there a deployed URL, a Dockerfile, a CI run, a changelog? Anything that says "this left my laptop" raises the floor on every other signal.

Notice what is absent from that list: model architecture cleverness, exotic libraries, and parameter counts. Those impress other researchers, not the people deciding whether you can be trusted with production. A portfolio that gets read is one that demonstrates the boring competence of shipping, made obvious in the first thirty seconds.

What to build: depth over breadth

The single most common portfolio mistake is breadth without depth — ten projects, each a thin wrapper around a tutorial, none deployed, none evaluated, none honest about its limits. The fix is counterintuitive but consistent across hiring advice as of 2026: build fewer projects, go deeper on each, and document them well. Three or four projects you can defend in detail beat a dozen you cannot.

Anchor the portfolio with a retrieval-augmented generation project. RAG is the most in-demand AI engineering skill as of 2026, and a strong RAG build demonstrates almost every production signal at once: data ingestion and chunking, embedding and retrieval, prompt assembly, evaluation, and the integration glue that holds it together. If you build only one thing well, make it this. Our step-by-step walk-through of hybrid retrieval for production RAG covers the BM25, vector, and re-ranking stack you will want to show.

Around that anchor, choose contrasting archetypes so the portfolio reads as range rather than repetition. The four below cover the spread that hiring managers want to see, and you can ship a credible portfolio with any three of them.

Archetype	What it proves	A concrete brief
RAG system (anchor)	Retrieval, chunking, evaluation, integration	A question-answering app over a real document set — council policy PDFs, NHS guidance, or Indian-language statutes — with hybrid retrieval and a measured answer-accuracy score.
Agent / tool-using system	Planning, tool calls, failure recovery	An agent that completes a multi-step task end to end — booking, research, or data extraction — with explicit retries and a trace of every tool call.
Evaluation or cost-optimisation	Rigour, measurement, engineering judgement	A golden-set eval harness or a cache-and-route layer that cuts API spend, with a before-and-after table proving the improvement.
Open-source contribution	Reading others' code, real-world collaboration	A merged pull request to a project such as LangChain, LlamaIndex, or Hugging Face Transformers — a scoped fix or a documented feature, not a typo correction.

The open-source archetype deserves emphasis. A single merged pull request to a well-known library is one of the strongest signals available, because it proves you can read an unfamiliar codebase, work within its conventions, and ship something that maintainers accepted. It also makes your name searchable in a context recruiters trust. For the wider mechanics of building credibility in public, see our guide to building in public as an AI engineer.

How to document each project

A brilliant project with a weak README is, for hiring purposes, a project that does not exist. Documentation is not an afterthought to the work — it is the work, because it is the part a reviewer actually consumes. The most reliable way to be ignored is to open your README with the tech stack. The most reliable way to be read is to open with the problem and the outcome, then earn the reader's attention for the detail.

Document every project around five things, in this order: the problem and who it was for; your approach and the key decisions you made; the metrics that show it works; how and where it is deployed; and what broke and how you fixed it. That last section — the honest account of what went wrong — is disproportionately persuasive, because it is the part nobody fakes. A candidate who can articulate the failure mode of their own retrieval pipeline is signalling exactly the production maturity reviewers are scanning for.

Here is a README skeleton that puts those five elements in the right order. Adapt the headings, but keep the sequence — problem and result first, deployment and failures made visible.

# PolicyQA — RAG assistant for council and NHS guidance

**Live demo:** https://policyqa.example.app  |  **Run locally:** `docker compose up`

A retrieval-augmented assistant that answers questions over 1,200 UK council and
NHS policy PDFs. Answers correctly on 91% of a 200-question held-out set, with a
median response time of 1.3s.

## The problem
Front-line caseworkers spend hours searching scanned policy PDFs for a single
clause. This tool answers natural-language questions and cites the source page.

## Approach
- Hybrid retrieval: BM25 + dense (bge-small) with a cross-encoder re-ranker.
- Hierarchical chunking by document section; metadata-filtered by policy area.
- Answers grounded with inline citations; refuses when retrieval confidence is low.

## Metrics (held-out set, n=200)
| Setup                     | Answer accuracy | Hallucination rate |
|---------------------------|-----------------|--------------------|
| Dense only                | 78%             | 9%                 |
| Hybrid + re-rank (final)  | 91%             | 2%                 |

## Deployment
Containerised, deployed on Fly.io behind a rate limiter. Vector store: Qdrant.
CI runs the eval suite on every push; a regression below 88% accuracy fails the build.

## What broke
- Scanned PDFs with two-column layouts shattered chunking. Fixed with a layout-aware
  parser before embedding.
- The model invented citations under low retrieval confidence. Added a confidence
  threshold and an explicit "I could not find this" fallback.

Note what the snippet does in its first three lines: it states the result (91% accuracy, 1.3s), gives a live link, and gives a one-command run instruction — all before the reader scrolls. The metrics table is small and honest, the deployment is concrete, and the "what broke" section turns flaws into evidence of judgement. This is the difference the source guidance points to between a list-of-tools README and a portfolio that earns the recruiter's extra engagement.

Where to host it and make it findable

Building the work and documenting it well is necessary but not sufficient. A perfect repository nobody can find is, in hiring terms, indistinguishable from no repository at all. The findability layer has three parts, and they reinforce one another.

First, GitHub — your repositories, pinned in priority order, with the strongest two or three at the top. This is where the code lives and where reviewers verify that you wrote it. For a focused audit of the profile itself, see our GitHub profile audit for AI engineers.

Second, a live demo for at least your anchor project. A hosted URL a reviewer can click is the single highest-engagement artefact you can offer, and it converts the abstract claim "I built a RAG system" into a thing that visibly works. Free and low-cost hosting tiers — Hugging Face Spaces, Fly.io, Railway, Cloudflare — make this achievable for any project.

Third, and most importantly for being found rather than merely verified, a single profile page that aggregates everything into one place a hiring manager can discover without first knowing your GitHub handle. This is the gap GitHub alone does not close: GitHub is searchable only if someone already has your name or is browsing a specific repo. A profile page in a directory the people hiring actively browse turns the search around — instead of you finding jobs, the jobs find you.

This is exactly what an AI Tech Connect Verified Builder profile is, and the connection is direct: the profile is itself a proof-of-work portfolio. It holds your bio, up to ten projects, and your work history on a single structured page — the same five-part story you tell in each README, aggregated and made discoverable. Recruiters and founders across India and the UK browse AI Tech Connect to shortlist builders and request contact details directly, so a strong profile does the finding for you. Link your GitHub and live demos from the profile, and link the profile from your GitHub README, and you have closed the loop: code that proves what you can build, and a page that makes that proof findable.

Weak portfolio signal	Strong portfolio signal
Ten shallow tutorial clones	Three to four deep, defensible projects
README opens with a tech-stack list	README opens with the problem and the result
Runs once in a notebook, never deployed	Live demo URL and one-command run instruction
No numbers, no evaluation	A small, honest metrics table
No mention of what went wrong	An explicit "what broke and how I fixed it" section
Work scattered, findable only by handle	One profile page the people hiring browse directly

Common pitfalls

Most weak portfolios fail in predictable ways. Knowing the failure modes in advance is the cheapest way to avoid them.

• Optimising for the weakest signals. Star counts and contribution graphs are proxies; live demos and merged pull requests are proof. Chasing stars while neglecting deployment is effort spent in the wrong place.
• Listing tools instead of outcomes. "Built with LangChain, Pinecone, and FastAPI" tells a reviewer nothing about whether the thing works. "Answers correctly 9 times in 10 on a held-out set, deployed for 40 weekly users" tells them everything.
• Hiding the failures. A README with no limitations section reads as either inexperience or dishonesty. The honest account of what broke is the most persuasive paragraph you can write.
• No live demo. If a reviewer cannot click through to a working thing, you have surrendered the highest-engagement artefact available to you.
• Building for nobody. A project with no real user and no metric cannot be defended in an interview. Pick problems that someone — even a study group or a local community — actually uses.
• Findable only if searched. Brilliant work that lives only on a GitHub profile nobody is browsing is invisible to the teams that would hire you. Aggregate it where they look.

Next steps

The path from here is concrete and short. As of 2026, you can build a portfolio that gets read in a handful of focused weekends rather than months.

1. Pick your anchor. Choose a RAG project with a real document set and a real user. Build it deeply — hybrid retrieval, an evaluation harness, a deployed demo.
2. Add range. Ship two or three contrasting archetypes — an agent, an evaluation or cost project, and ideally one merged open-source contribution.
3. Document for the ten-second read. Open each README with the problem and the result, include a metrics table, make the deployment visible, and write the honest "what broke" section.
4. Make it findable. Pin your strongest repos, host a live demo, and aggregate everything onto a single profile page the people hiring browse.

That final step is where AI Tech Connect fits. Your Verified Builder profile is a proof-of-work portfolio in its own right — bio, up to ten projects, and work history on one page that recruiters and founders across India and the UK use to shortlist builders directly. It is free, takes about two minutes, needs no CV, and early Founding Builder spots are limited. For more on the hiring side of all this, our analysis of the AI talent gap and the shortage of verified builders explains why proof-of-work is now the deciding factor, and our guide to five portfolio projects that get you hired gives concrete project briefs to start from.