Monthly Skills Audit

A monthly learning review skill that tracks skills developed, courses completed, books read, and certifications earned — then performs a gap analysis against your stated career goals. Integrates with learning platforms like Udemy, Coursera, LinkedIn Learning, and reading trackers like Goodreads to pull completion data automatically.

Supported Platforms & Integrations

Platform	Setup Method	Auth Type	Notes
Udemy	API or completion export	OAuth2 / CSV	Tracks course progress and completion certificates
Coursera	Completion export	CSV	Course and specialization completion data
LinkedIn Learning	Activity export	CSV	Watched courses and learning hours
Goodreads	CSV export or API	API key	Books read with ratings and shelves
GitHub	API token	REST API	Contribution activity as proxy for technical skill practice
Notion	Integration token	OAuth2	Learning database with custom skill tracking

When to Use This Skill

• Use this at the end of each month to honestly assess what you actually learned versus what you planned to learn
• Use this when preparing for a career transition and need to identify the skill gaps between your current role and target role
• Use this when you feel like you are consuming lots of learning content but cannot articulate what skills improved
• Use this when annual review season approaches and you need a documented record of professional development
• Use this when you want to prioritize which skills to focus on next based on career impact analysis
• Consider alternatives when you need a detailed technical assessment of coding skills — use platforms like HackerRank or Pluralsight skill assessments
• Consider alternatives when you need formal mentorship matching — this tracks progress but does not connect you with mentors

Quick Start

Copy
# ~/.claude/skills/monthly-skills-audit.yaml
career_goal: "Senior Full-Stack Engineer"
target_timeline_months: 12
skill_categories:
  technical:
    - TypeScript
    - React
    - Node.js
    - PostgreSQL
    - AWS
    - System Design
  soft_skills:
    - Technical Writing
    - Team Leadership
    - Public Speaking
current_proficiency:
  TypeScript: intermediate
  React: intermediate
  Node.js: beginner
  PostgreSQL: beginner
  AWS: beginner
  System_Design: beginner
learning_sources:
  - udemy
  - goodreads
  - github
history_file: ~/.skills-audit/history.json

First Run Example

Copy
claude skill monthly-skills-audit --month 2026-03

Expected Output

Monthly Skills Audit — March 2026
===================================

Career Goal: Senior Full-Stack Engineer (9 months remaining)

LEARNING ACTIVITY
  Courses completed: 1 (Node.js Masterclass on Udemy — 22 hours)
  Courses in progress: 2 (AWS Solutions Architect, System Design)
  Books finished: 1 ("Designing Data-Intensive Applications")
  Books in progress: 1 ("Staff Engineer" by Will Larson)
  GitHub contributions: 47 commits, 3 PRs merged
  Total learning hours: ~34 hours

SKILL PROGRESS
  TypeScript:      Intermediate --> Intermediate (maintained)
  React:           Intermediate --> Intermediate (maintained)
  Node.js:         Beginner --> Intermediate (LEVELED UP - course completed)
  PostgreSQL:      Beginner --> Beginner (no focused learning this month)
  AWS:             Beginner --> Beginner (course 40% complete)
  System Design:   Beginner --> Beginner (course 25% complete, book read)
  Tech Writing:    None --> Beginner (2 blog posts drafted)
  Leadership:      None --> None (no activity)
  Public Speaking: None --> None (no activity)

GAP ANALYSIS vs Senior Full-Stack Engineer
  Skills at target level:     2 of 9 (22%)
  Skills approaching target:  3 of 9 (33%)
  Skills needing attention:   4 of 9 (44%)

  Biggest gap: AWS (need intermediate+, currently beginner)
  On track: Node.js (just leveled up, keep building)
  At risk: Leadership and Public Speaking (0 activity in 3 months)

NEXT MONTH PRIORITIES
  1. Complete AWS Solutions Architect course (20 hours remaining)
  2. Build one Node.js project to reinforce new skills
  3. Sign up for one meetup talk or lightning talk (Public Speaking)

Timeline Check: 9 months to goal — need to accelerate AWS and soft skills

Advanced Configuration

Platform-Specific Setup

Udemy Progress Tracking

Copy
udemy:
  enabled: true
  export_path: ~/Learning/udemy_history.csv
  track_hours: true
  completion_threshold: 90
  include_ratings: true

GitHub Activity as Skill Proxy

Copy
github:
  enabled: true
  username: "your-github-username"
  token: "your-github-token"
  track_languages: true
  track_contributions: true
  skill_mapping:
    TypeScript: ["*.ts", "*.tsx"]
    Python: ["*.py"]
    React: ["*.tsx", "*.jsx"]

Full Options Reference

Parameter	Type	Default	Description
career_goal	string	required	Target role or career milestone
target_timeline_months	int	12	Months to reach the career goal
skill_categories	map	{}	Technical and soft skills to track
current_proficiency	map	{}	Starting proficiency level per skill
proficiency_scale	list	[none, beginner, intermediate, advanced, expert]	Scale for rating skill levels
learning_sources	list	[]	Platforms to pull data from
history_file	string	~/.skills-audit/history.json	Where to store monthly audit data
include_gap_analysis	bool	true	Compare current skills against career goal requirements
include_recommendations	bool	true	Generate next-month learning priorities
github_as_practice	bool	true	Count coding activity as skill reinforcement
book_counts_as_hours	float	5	Estimated hours per book finished
certification_tracking	bool	true	Track certification progress and expiration dates
output_format	string	terminal	terminal, markdown, notion, or csv

Core Concepts

Concept	Purpose	How It Works
Proficiency Levels	Standardizes self-assessment	Five-level scale from none to expert, updated monthly based on evidence
Gap Analysis	Identifies what matters most	Compares current proficiency map against target role requirements
Learning Velocity	Tracks pace of skill acquisition	Measures hours invested and levels gained per month to project completion
Skill Decay Detection	Prevents regression	Flags skills with no practice in 60+ days as at risk of declining
Evidence-Based Leveling	Prevents wishful assessment	Requires concrete evidence (course, project, contribution) to move up a level

Architecture

Learning Platform Data (Udemy / Coursera / GitHub / Goodreads)
                    |
                    v
          +--------------------+
          | Data Aggregator    |----> Normalizes completions and hours
          +--------------------+
                    |
                    v
          +--------------------+
          | Proficiency Updater|----> Evaluates evidence for level changes
          +--------------------+
                    |
          +---------+---------+
          |                   |
          v                   v
  +---------------+   +------------------+
  | Gap Analyzer  |   | Velocity Tracker |
  | (vs career    |   | (hours + levels  |
  |  goal)        |   |  per month)      |
  +---------------+   +------------------+
          |                   |
          v                   v
  +-------------------------------+
  | Report + Recommendations      |
  +-------------------------------+

Workflow Examples

Scenario 1: Career Transition Preparation

Input: Backend engineer aiming for full-stack role in 6 months

Processing:
  - Maps current backend skills (strong) vs frontend requirements (gaps)
  - Identifies React, CSS, and UX fundamentals as primary gaps
  - Calculates learning hours needed based on course lengths
  - Creates a 6-month learning roadmap with monthly milestones

Output:
  Gap Summary: 3 critical frontend skills missing
  Estimated learning investment: 120 hours over 6 months (20 hrs/month)
  Month 1-2: React fundamentals course (40 hours)
  Month 3-4: CSS/design systems + build 2 frontend projects
  Month 5-6: Full-stack project combining backend expertise with new frontend skills
  Checkpoint: Apply for internal full-stack role at month 5

Scenario 2: Certification Expiration Warning

Input: AWS Solutions Architect cert expires in 45 days

Processing:
  - Detects upcoming certification expiration from tracking data
  - Checks recertification requirements (exam or continuing education)
  - Estimates study time needed based on last certification prep

Output:
  CERTIFICATION ALERT: AWS Solutions Architect expires April 30, 2026
  Recertification options:
    A) Retake certification exam ($150, ~20 hours study)
    B) Pass higher-level exam (Professional level counts as renewal)
  Recommendation: Schedule exam for April 20 and begin review this week
  Study plan: 1 hour/day for 3 weeks using practice exams

Scenario 3: Skill Stagnation Detection

Input: 4 months of history showing no level changes in any skill

Processing:
  - Detects zero proficiency level changes in 4 consecutive months
  - Checks learning hours (found: 8 hrs/month avg — low)
  - Analyzes pattern: courses started but not completed (3 abandoned)

Output:
  STAGNATION ALERT: No skill level improvements in 4 months
  Root cause analysis:
    - Average learning time: 8 hrs/month (target: 20 hrs/month)
    - 3 courses started and abandoned before 50% completion
    - Pattern: Starting too many courses simultaneously
  Recommendation: Commit to ONE course to completion before starting another
  Suggested: Finish AWS course (60% done, ~12 hours remaining)

Best Practices

1. Level up based on evidence, not time spent — Watching 40 hours of video does not make you intermediate. Require yourself to build something, pass a test, or explain a concept clearly before moving up a proficiency level.

2. Track learning hours honestly — Only count focused learning time. Having a tutorial playing in the background while checking email does not count. Honest tracking reveals your actual learning investment.

3. Focus on one skill gap per month — Spreading attention across five skills means none of them progress meaningfully. Dedicate 80% of your learning time to one priority skill and use the remaining 20% for maintenance.

4. Include soft skills in the audit — Technical skills alone do not lead to senior roles. Leadership, communication, and writing are often the actual gaps. Give them equal tracking weight in your audit.

5. Connect learning to projects immediately — Every course or book should be followed by a hands-on project applying what you learned. Add a project requirement to each skill before marking it as leveled up.

Common Issues

1. Proficiency levels feel subjective — Define concrete criteria for each level in your config file. For example: beginner means completed one course, intermediate means built a project, advanced means mentored someone else on it.

2. Too many skills to track — Limit your active tracking to 6-8 skills maximum. Archive skills that are stable and only audit them quarterly instead of monthly.

3. GitHub data does not reflect learning — Code contributions are a proxy for practice, not learning. A month of writing boilerplate TypeScript does not advance your TypeScript proficiency. Weight course completions and projects higher than commit counts.

Privacy & Data Handling

All skills audit data is processed and stored locally in ~/.skills-audit/. Your career goals, proficiency assessments, and learning history never leave your machine. Platform API tokens for GitHub, Udemy, or Goodreads are stored in your local Claude configuration and are not shared. Course completion data is read from your exported files or pulled via API to your local machine only. If Notion export is enabled, data goes only to your own workspace. No learning data is used for any purpose beyond generating your personal monthly report.