How /expand Enriches Candidate Profiles by Scanning GitHub Repositories and Course Syllabi

The /expand command automatically discovers hidden competencies from linked GitHub repositories and course syllabi through a six-stage pipeline that extracts technical skills from README files, programming languages, and official curricula, then appends them to the candidate profile with full source attribution.

The ai-job-search repository by MadsLorentzen includes a sophisticated competency enrichment system that eliminates manual resume updates. The /expand command, defined in .claude/commands/expand.md, orchestrates an automated pipeline that scans public GitHub repositories and educational content to surface implicit technical skills. This approach ensures that every framework mention in a project README or certification syllabus gets captured as a concrete profile entry.

The Six-Stage Enrichment Architecture

Stage 0 – Profile Baseline Loading

The pipeline begins by reading 01-candidate-profile.md and 02-behavioral-profile.md to establish existing competencies. This prevents duplication and informs the discovery algorithms about the candidate's current skill baseline.

Stage 1 – Multi-Source Discovery

The system traverses several document sources in fixed order:

• Documents: CV files in documents/cv/, LinkedIn exports in documents/linkedin/, diplomas, and references
• GitHub: Retrieves the public profile using the username from the candidate profile, then fetches all repositories (not merely pinned ones), extracting README content, repository names, descriptions, languages, topics, and explicit framework mentions
• External URLs: Portfolio sites, Kaggle profiles, and Google Scholar pages

Stage 2 – Dual-Mode Web Enrichment

For each discovered experience item, the system applies two complementary approaches:

• Approach A: Direct lookup of official syllabi, certification exam guides, and tool documentation (e.g., "Coursera – Deep Learning Specialisation syllabus")
• Approach B: Contextual inference from textual descriptions, domain requirements, and typical tool-chain associations

Both results merge into a unified competency list.

Stage 3 – Competency Classification

Discovered skills undergo deduplication and classification into five buckets:

• Technical Skills – Primary
• Technical Skills – Secondary
• Domain Knowledge
• Methods & Practices
• Soft / Behavioral

Each entry preserves its source metadata and discovery method (direct lookup vs. inference).

Stage 4 – Interactive Review

The system generates a markdown summary table grouping new competencies by source type (courses, GitHub repos, job responsibilities). Candidates choose between adding everything, reviewing by group, or skipping entirely. No files modify until explicit confirmation.

Stage 5 – Additive Write-Back

Confirmed competencies append to the appropriate profile sections using additive-only operations. Each entry includes inline source annotations like *(GitHub — my-project)* or *(Coursera — Deep Learning Specialisation)*.

Stage 6 – Execution Report

The command outputs a final "/expand Complete" report detailing additions, processed sources, and items requiring manual review.

Deep GitHub Repository Analysis

Unlike simple profile imports that only check pinned repositories, the /expand command performs exhaustive scanning of all public repositories. For each repository found under the candidate's GitHub username, the system fetches the README to capture:

• Repository metadata: Name, description, and topics
• Language statistics: Primary and secondary programming languages
• Framework detection: Explicit mentions of tools like TensorFlow, FastAPI, or Docker in documentation
• Project context: Inferred domains based on README content and tech stack combinations

This ensures that side projects and older repositories contribute equally to skill recognition, not just curated pinned items.

Course Syllabus Intelligence

The command treats educational credentials as skill vectors rather than simple line items. When processing courses or certifications from documents/diplomas/ or LinkedIn exports, the system:

• Locates official syllabi and certification exam guides through web search
• Extracts specific technical competencies (e.g., "Back-propagation" from a Deep Learning Specialization)
• Cross-references implied skills from course descriptions when official syllabi are unavailable

Running the /expand Command

Execution requires no parameters:

/expand

The console displays a structured progress log:

## /expand found 27 new competency signals across 5 sources

**COURSES & CERTIFICATIONS**
Source: Coursera — Deep Learning Specialisation
  + Neural Networks
  + Back-propagation
  + TensorFlow

**GITHUB — my-awesome-repo**
Source: README + inferred from tech stack
  + Python
  + FastAPI
  + Docker

At completion, the system prompts:

> How would you like to proceed?
> - `all` — Add everything above to your profile
> - `review` — Walk through each source group
> - `skip` — Cancel without writing anything

Responding all triggers the write-back phase, appending entries to the profile files:

### Technical Skills — Primary

- Python *(GitHub — my-awesome-repo)*
- TensorFlow *(Coursera — Deep Learning Specialisation)*
- FastAPI *(GitHub — my-awesome-repo)*

Source Traceability and Idempotency

The implementation guarantees additive-only operations—existing profile content never gets overwritten. The source-traceable design attaches provenance metadata to every entry, creating an audit trail from discovery to profile integration.

The system is also idempotent: repeated executions filter out previously added competencies by checking existing source tags. If /expand runs twice against the same GitHub repository, the second execution recognizes the *(GitHub — repo-name)* annotations and excludes duplicates.

Summary

• The /expand command in MadsLorentzen/ai-job-search automates competency discovery through a six-stage pipeline defined in .claude/commands/expand.md
• GitHub scanning retrieves all public repositories, extracting skills from README content, languages, and topics—not just pinned items
• Course syllabi enrichment combines direct syllabus lookups with contextual inference to capture specific technical methods
• The additive-only write-back system preserves existing profile data while appending new entries with full source attribution
• Idempotent execution prevents duplication across multiple runs by filtering against existing source tags

Frequently Asked Questions

Does /expand modify my existing profile content?

No. The command operates on an additive-only basis. It appends newly discovered competencies to 01-candidate-profile.md and 02-behavioral-profile.md but never deletes or alters existing entries. Each addition includes a source annotation to maintain data integrity.

How does the system handle private GitHub repositories?

The command only processes public repositories associated with the username specified in the candidate profile. Private repositories remain inaccessible to the enrichment pipeline, ensuring compliance with repository visibility settings.

Can I review the discovered competencies before they get added to my profile?

Yes. Stage 4 of the pipeline generates an interactive review interface that displays all proposed additions grouped by source type (courses, GitHub repos, certifications). You can choose to add everything at once (all), review by category (review), or cancel the operation entirely (skip).

What prevents duplicate entries if I run /expand multiple times?

The system implements idempotency through source-tagged entries. Each competency carries an inline annotation like *(GitHub — repo-name)* or *(Coursera — Course Title)*. Subsequent executions filter out any competencies matching existing source signatures, ensuring clean, deduplicated profile files.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}