How to Build an AI Training Needs Assessment System

Most companies guess at training needs. I built an ai training needs assessment system that maps required skills against actual capabilities, identifies gaps, and recommends specific training for each employee. Data-driven employee development instead of assumptions.

The system compares what the role requires to what the person currently demonstrates.

What You Need Before Starting

• Python 3.8+
• An AI API key (Claude)
• Role competency frameworks
• Employee performance data or self-assessments

Step 1: Define Role Competency Frameworks

COMPETENCY_FRAMEWORKS = {
    "senior_developer": {
        "technical": {
            "python": {"required": 4, "weight": 3},
            "system_design": {"required": 4, "weight": 3},
            "testing": {"required": 3, "weight": 2},
            "devops": {"required": 3, "weight": 2},
            "security": {"required": 2, "weight": 1}
        },
        "soft_skills": {
            "communication": {"required": 4, "weight": 2},
            "mentoring": {"required": 3, "weight": 2},
            "project_management": {"required": 3, "weight": 1}
        }
    }
}
# Levels: 1=Beginner, 2=Developing, 3=Competent, 4=Advanced, 5=Expert

Step 2: Collect Skill Assessments

import sqlite3

def init_skills_db(db_path="skills.db"):
    conn = sqlite3.connect(db_path)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS assessments (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            employee_name TEXT,
            role TEXT,
            skill_name TEXT,
            self_score INTEGER,
            manager_score INTEGER,
            assessed_date TEXT
        )
    """)
    conn.commit()
    return conn

def record_assessment(conn, employee, role, scores):
    from datetime import datetime
    for skill, data in scores.items():
        conn.execute(
            "INSERT INTO assessments (employee_name, role, skill_name, self_score, manager_score, assessed_date) VALUES (?,?,?,?,?,?)",
            (employee, role, skill, data.get("self", 0), data.get("manager", 0), datetime.now().isoformat())
        )
    conn.commit()

Step 3: Identify Gaps

def analyze_gaps(conn, employee, role):
    framework = COMPETENCY_FRAMEWORKS.get(role, {})
    assessments = conn.execute(
        "SELECT skill_name, self_score, manager_score FROM assessments WHERE employee_name=? AND role=?",
        (employee, role)
    ).fetchall()

    score_map = {row[0]: {"self": row[1], "manager": row[2]} for row in assessments}
    gaps = []

    for category, skills in framework.items():
        for skill, requirements in skills.items():
            current = score_map.get(skill, {"self": 0, "manager": 0})
            avg_score = (current["self"] + current["manager"]) / 2
            gap = requirements["required"] - avg_score

            if gap > 0:
                gaps.append({
                    "skill": skill,
                    "category": category,
                    "current_level": avg_score,
                    "required_level": requirements["required"],
                    "gap": round(gap, 1),
                    "priority": round(gap * requirements["weight"], 1)
                })

    gaps.sort(key=lambda x: -x["priority"])
    return gaps

Step 4: Generate Training Recommendations with AI

import anthropic
import json

client = anthropic.Anthropic()

def recommend_training(gaps, employee_name):
    prompt = f"""Based on these skill gaps for {employee_name}, recommend specific training.

Gaps (sorted by priority):
{json.dumps(gaps[:10], indent=2)}

For each gap, recommend:
1. One online course or certification (with provider name)
2. One hands-on project to build the skill
3. Estimated time to close the gap

Return as JSON array."""

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    )
    return json.loads(message.content[0].text)

Step 5: Generate the Development Plan

def create_development_plan(employee, gaps, recommendations):
    plan = f"# Development Plan: {employee}\n\n"
    plan += f"Generated: {datetime.now().strftime('%Y-%m-%d')}\n\n"
    plan += f"## Priority Skill Gaps\n\n"

    for gap in gaps[:5]:
        plan += f"### {gap['skill'].replace('_', ' ').title()}\n"
        plan += f"Current: {gap['current_level']}/5 | Required: {gap['required_level']}/5\n\n"

    plan += "## Recommended Training\n\n"
    for rec in recommendations:
        plan += f"- **{rec.get('skill', 'N/A')}**: {rec.get('course', 'N/A')}\n"
        plan += f"  Project: {rec.get('project', 'N/A')}\n"
        plan += f"  Timeline: {rec.get('timeline', 'N/A')}\n\n"

    return plan

What to Build Next

Add quarterly reassessment that measures progress against the plan. Track whether recommended training actually closes the gaps. The assessment is the diagnosis. The follow-up measurement is what drives real development.

Related Reading

• The Feedback Loop That Powers Everything - closing the loop on development
• How Systems Compound Over Time - why skill tracking compounds
• AI-Powered Reporting That Actually Gets Read - making assessment reports actionable