Three working systems, zero visibility until now: publish your AI operator portfolio and become the candidate recruiters actually find
For procurement, supply-chain, and operations professionals who've built real AI systems in this programme and need a public portfolio that gets them hired, not just noticed
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 by practitioners, not influencers
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. Your system gets better, not obsolete.
You've done the hard work: you built a personal OS, a team harness, a job search OS. But every bit of it lives on your own machine, invisible to the recruiters and hiring managers who are right now searching LinkedIn and GitHub for exactly the kind of AI-native operator you've become. Your LinkedIn headline still says something generic, your GitHub bio is blank, and your repos are private. Applications go unanswered not because your skills aren't real, but because there's no public evidence they exist. Meanwhile, candidates with shallower skills but polished, visible portfolios are getting the interviews you're not.
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
Most candidates applying for AI-native operations roles have a CV that claims skills and no public evidence to back it up. You'll leave this course with three verifiable repos, a live build log, and two optimised profiles that let a hiring manager check your reasoning before the interview even starts, which puts you in a category of one compared with everyone else in the shortlist.
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 programme and need their work to be visible to recruiters, not just functional on their own machine
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 to stand out from candidates who only have a CV and no public evidence of real capability
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
I have no coding background at all. Will I actually be able to follow this?
Yes, and that's the design intention. 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 exactly 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 programme yet. Can I still take this one?
This course is built on the assumption that you have the three repos, personal OS from AC 202, team harness from AC 203, and job search OS from AC 204, ready to publish. The entire first section works through those specific repos. If you haven't built them yet, complete those courses first, then come back here: 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 directly in L1 and L2 precisely because it's a real, recoverable problem only if you catch it early. The checklist you run in L2 covers full git history, not just current files, before you flip visibility. That's the whole point of sanitising before publishing rather than after. The lesson is explicit that a public repo's history is permanent and searchable, which is why the checklist step happens first, not as an afterthought.
How does the course stay current as LinkedIn and GitHub update their interfaces?
Because the course teaches a structured approach, the problem-system-result README structure, the full-history sanitisation checklist, the keyword worksheet logic, none of that depends on a specific button being in a specific place in a UI. Where interface steps are involved, the course is reviewed and updated when significant changes occur. Active subscribers are notified when updates are published.
What's the refund policy, and can I use what I build commercially?
There's a 14-day refund window from the date of purchase, no questions asked. Everything you produce during the course, the repos, the READMEs, the LinkedIn posts, the keyword worksheet, belongs to you. You built it using your own real work from your own real systems. Use it however serves your career, including in job applications, interviews, and professional profiles.