Publish your AI portfolio on GitHub and LinkedIn
You've built three working AI systems and nobody can see them yet. For procurement, supply-chain and operations professionals in this program who need a public portfolio that recruiters can find.
4 chapters, 7 lessons
14-day refund on the yearly plan. Real pricing on the plans page, no surprises.
7
lessons, yours to run
Easy to pick up, built to get you the next job
No coding background needed, and you write code with Claude as you go.
Every section below turns into something a hiring manager recognises, not just notes.
Publish three real systems safely and confidently
- You'll audit your personal OS, team harness, and job search OS repos against a full-history sanitisation checklist before a single file goes public, no coding background needed, just a clear process you follow once
- You'll apply a consistent top-level repo structure across all three, so a recruiter can navigate any one of them in seconds without relearning the layout
- You'll flip all three repos public in one sitting, producing the kind of deliberate, structured portfolio that hiring managers recognise as real professional discipline
Write READMEs that demonstrate judgment, not just code
- You'll write one README per repo using a strict problem, system, result structure that a recruiter can read in under a minute and immediately understand what you solved and how you know it worked
- You'll anchor every result in a specific, checkable figure, not a vague claim, because interviewers grade reasoning and repeatability, and this is where you show both
- You'll point each README directly to the one file that proves your claim, so a reviewer can verify it in a single click rather than taking you on faith
Build a four-week LinkedIn log that reads like a track record
- You'll plan and draft four weeks of posts across three story types: what you built, what broke, and what the results actually were, mapped to real material from your repos
- You'll publish the first two posts, track genuine engagement rather than raw view counts, and adjust the next draft based on what actually resonated
- You'll produce a visible, consistent build log that hiring managers recognise as structured process, exactly the quality AC 100's argument about screened candidates points to
Get surfaced by recruiter searches rather than hoping to be found
- You'll complete a keyword worksheet mapping the actual search terms technical recruiters use for AI-native candidates against skills you've genuinely built, no stuffing, only terms that are verifiably true
- You'll rewrite your LinkedIn headline and GitHub bio so both profiles use language that matches what a recruiter types, not a generic phrase shared by thousands of other profiles
- You'll leave the course with two optimised public profiles pointing directly at three sanitised, recruiter-readable repos, a complete, searchable presence any employer can verify
Finish this course and you can do all of this, no prior background required:
- You'll be able to publish a three-repo GitHub portfolio that is sanitised, consistently structured, and immediately navigable to a non-technical recruiter, the kind of deliberate presentation hiring m
- You'll be able to write READMEs that demonstrate structured reasoning and measurable results, the two things interviewers screen for long before they open a single file
- You'll be able to maintain a consistent LinkedIn build log covering what you shipped, what broke, and what the numbers actually showed, visible proof of the iterative process employers pay for
- You'll be able to optimise both your LinkedIn and GitHub profiles with the exact keyword language technical recruiters search, so inbound interest comes to you rather than depending entirely on applic
- You'll be able to point every README claim directly to a specific, verifiable file, giving a reviewer the confidence that comes from evidence rather than assertion
- You'll be able to present a complete public portfolio, three repos plus a live build log plus two searchable profiles, that functions as a working demo of AI-native skills no other candidate in the ro
7 lessons, 4 chapters
Built from real implementation work
Every agent, skill file, and dataset is drawn from 25+ years and 50+ Oracle ERP implementations across pharma, manufacturing, semiconductor, and distribution.
Kept current with the stack
Claude Code, skills, and MCP move fast. Your licence includes every system update for as long as you're subscribed, so what you build keeps working as the tools change.
An AI portfolio on GitHub and LinkedIn is how the work you've done becomes visible. You built a personal OS, a team system and a job search OS. Right now all of it lives on your own machine. Your LinkedIn headline is generic, your GitHub bio is blank and your repos are private. Recruiters and hiring managers search LinkedIn and GitHub for AI-native operators, and they can't find any evidence of yours. Applications go unanswered because there's nothing public to check. This course turns those three systems into a public portfolio, safely: repo architecture for a recruiter audience, READMEs that explain your thinking, a four-week LinkedIn build log and search optimisation so recruiters find you.
What you'll be able to do, module by module
Every module leaves you able to build and run something real. Here is the syllabus, in the order you work through it.
Curriculum
4 chapters · 7 lessons
Section 1: The GitHub Portfolio
You'll publish three sanitised, consistently structured public repos with READMEs that state a real problem, describe the system you built, and cite a specific measurable result, giving any recruiter a portfolio they can evaluate in under a minute
Chapter 1.1: Architecture for a Recruiter Audience3 items
- L1: What Stays Private, What Goes Public🔒
- L2: Workbook: Publish Your 3 Repos🔒
- Quiz: Portfolio RulesQuiz
Chapter 1.2: READMEs That Sell Your Thinking2 items
- L3: Workbook: Write 3 READMEs With Figures🔒
- L4: Case Study: The README a Recruiter Read for 4 Minutes🔒
Section 2: The LinkedIn Build Log
You'll plan a four-week content calendar across build, failure, and results story types, draft and publish the first two posts, track real engagement, and produce an iterating build log that reads as structured, repeatable professional process
Chapter 2.1: Publish What You Built and What Broke3 items
- L5: Workbook: Your 4 Week Content Calendar🔒
- L6: Workbook: Publish Posts 1 and 2🔒
- Quiz: Build Log CraftQuiz
Section 3: Getting Found
You'll rewrite your LinkedIn headline and GitHub bio using a keyword worksheet tied to skills you've genuinely built, so your profile surfaces in the searches recruiters actually run for AI-native candidates rather than staying buried in generic results
Chapter 3.1: Search Optimization for Candidates2 items
- L7: Workbook: Optimize Headline, Profile, and Keywords🔒
- Course Final: VisibilityQuiz
You'll leave with three verifiable repos, a live build log and two optimised profiles. A hiring manager can check your reasoning before the interview starts, instead of taking a CV's claims on trust.
From subscribing to running your first artifact
Subscribe and open the workbook
Every lesson in this course is workbook-style: you get a clear checklist or template, you apply it to your own three repos and your own LinkedIn profile, and you're done. No slides to watch passively. No coding environment to configure. Open the course and start lesson one.
Sanitise, structure, and publish your first repo
Lesson one walks you through the full-history sanitisation checklist, what stays public and what must stay private, applied to your personal OS repo. By the end of that first session you'll have one live, recruiter-readable public repo with a structured layout, a CLAUDE.md, and a skills folder in place.
Build out the full portfolio and go searchable
You work through the remaining repos, write all three READMEs to the problem-system-result template, plan and publish your first two LinkedIn build log posts, and optimise both your LinkedIn headline and your GitHub bio with verified, searchable keywords. At the end you have three public repos, a live build log, and two profiles that surface in recruiter searches.
From private repo to recruiter interview in four steps
Sanitise before a single file goes public
You run the full-history checklist on your job search OS repo. The current files look clean, but searching the git history surfaces a token you pasted into a test six weeks ago. You remove it from history before flipping visibility. The repo goes public with nothing recoverable that shouldn't be there.
Apply consistent structure across all three repos
You set the same top-level layout, README.md, CLAUDE.md, skills folder, working folder, across your personal OS and team harness repos. A recruiter who opens any one of them immediately knows where to look without relearning the layout each time.
Write the README a recruiter actually reads
For the job search OS repo you write one paragraph on the problem, one paragraph on the system, and one sentence on the result with a real figure: 40 companies tracked across four pipeline stages, time to update the tracker cut from twenty minutes to under two. You link directly to the tracker file so the claim is verifiable in one click.
Get found before you apply
You rewrite your LinkedIn headline using terms from the keyword worksheet, replacing a generic student phrase with language that matches what a recruiter searching for AI-native operations candidates actually types. Within the week a recruiter messages you after finding your profile in a search, having read the README you wrote in step three.
The toolkit you'll build and run in this program
You leave with working assets, not notes.
Real things you can demo in an interview.
Three live, sanitised, publicly accessible GitHub repos with consistent structure across all of them
Three recruiter-ready READMEs following the problem-system-result template, each with a specific measurable figure
A four-week LinkedIn content calendar with full drafts for the first two posts and an 8-post template library covering build, failure, and results stories
A keyword worksheet mapping real, verifiable skills to the search terms technical recruiters use for AI-native candidates
An optimised LinkedIn headline and GitHub bio that surface your profile in relevant recruiter searches
Two published, engagement-tracked LinkedIn posts with a documented iteration between them, demonstrating repeatable structured process
You'll get the most from this if
Procurement and supply-chain professionals who've completed earlier courses in this program and need recruiters to see that work
Operations and category management practitioners who want their next role to find them rather than spending every spare hour sending applications into silence
Early-career professionals and students in operations, sourcing or logistics who want public evidence of real capability to sit alongside their CV
Anyone who has built AI-assisted systems for real procurement or supply-chain work and needs a structured, safe way to present that work publicly without leaking credentials or sensitive data
Yearly plan: 14-day keep-the-system guarantee
14-day refund on the yearly plan. Finish the first two modules, and if you haven't run your first live pipeline, take a full refund.
Straight answers before you subscribe
What goes into an AI portfolio on GitHub and LinkedIn?
Your three repos from AC 202, AC 203 and AC 204, sanitised and published with a repo architecture aimed at recruiters. Each gets a README that explains your thinking with a problem, system, result structure. On LinkedIn you run a four-week build log and use a keyword worksheet so recruiters find you in search.
I have no coding background at all. Can I follow this?
Yes, and the course is designed for that. Every lesson is workbook-style: you get a checklist, a template or a worksheet, and you apply it to your own repos and profiles. There's no code to write in this course. The sanitisation checklist tells you what to search for and what to do if you find it. The README template tells you the three sections to write and in what order. If you can paste text and click a toggle in GitHub's settings, you can complete every lesson.
I haven't finished the earlier courses in the program yet. Can I still take this one?
This course assumes you have three repos ready to publish: the personal OS from AC 202, the team system from AC 203 and the job search OS from AC 204. The whole first section works through those repos. If you haven't built them yet, complete those courses first and then come back. The portfolio lessons will make far more sense and produce far more useful output.
What if I publish a repo and realise I've missed something sensitive in the history?
The course covers this in L1 and L2, because it's only recoverable if you catch it early. The checklist you run in L2 covers the full git history, as well as the current files, before you change visibility. That's why you sanitise before publishing. The lesson is clear that a public repo's history is permanent and searchable, which is why the checklist step comes first.
How does the course stay current as LinkedIn and GitHub update their interfaces?
The course teaches a structured approach: the problem, system, result README structure, the full-history sanitisation checklist and the keyword worksheet logic. None of that depends on a button being in a particular place. Where interface steps are involved, the course is reviewed and updated when significant changes occur. Active subscribers are told when updates are published.
What's the refund policy, and can I use what I build commercially?
Refunds depend on the plan. The yearly plan has a 14-day full refund. In India every plan is a one-time pass that isn't refunded, but it never renews without you, and you can try a free lesson before you buy. The refunds page has the full policy. Everything you produce during the course belongs to you, including the repos, READMEs, LinkedIn posts and keyword worksheet. Use it in job applications, interviews and professional profiles.