# Career Transition Pathways

Cubit identifies skill-adjacent career transitions-helping workers move from high-exposure roles to more resilient positions with minimal retraining.

**Tier Required:** Enterprise

## The Transition Challenge

When a job faces automation pressure, the question becomes: **Where can these workers go?**

A good transition pathway has:

* **High skill overlap** - Workers can leverage existing capabilities
* **Positive resilience gain** - The target job is more protected
* **Realistic retraining** - Gap skills are learnable

## Finding Transitions (Enterprise)

The `find_transitions` endpoint automates pathway discovery:

```python
from cubit import CubitClient

client = CubitClient("cubit_your_enterprise_key")

transitions = client.find_transitions(
    source_soc="43-3031.00",  # Bookkeeping Clerks (high exposure)
    similarity_threshold=0.7,  # Require 70%+ skill overlap
    max_results=10,
    filters={
        "min_resilience_gain": 10,  # At least +10 improvement
        "require_positive_growth": True  # Only growing occupations
    }
)

print(f"Transitions from: {transitions['source_job']['title']}")
print(f"Current resilience: {transitions['source_job']['human_centric_resilience_score']:.0f}/100\n")

for t in transitions["transitions"]:
    print(f"-> {t['target_title']}")
    print(f"   Skill similarity: {t['skill_similarity']:.0%}")
    print(f"   Resilience gain: +{t['resilience_gain']:.0f}")
    print(f"   Difficulty: {t['transition_difficulty']}")
    print(f"   Overlapping skills: {', '.join(t['overlapping_skills'][:3])}")
    print(f"   Skills to develop: {', '.join(t['gap_skills'][:3])}")
    print()
```

**Output:**

```
Transitions from: Bookkeeping, Accounting, and Auditing Clerks
Current resilience: 49/100

-> Gambling Cage Workers
   Skill similarity: 81%
   Resilience gain: +11
   Difficulty: low
   Overlapping skills: Mathematics, Active Listening, Speaking
   Skills to develop: Service Orientation, Social Perceptiveness

-> Financial Managers
   Skill similarity: 77%
   Resilience gain: +10
   Difficulty: medium
   Overlapping skills: Mathematics, Critical Thinking, Reading Comprehension
   Skills to develop: Complex Problem Solving, Judgment and Decision Making

-> Order Clerks
   Skill similarity: 73%
   Resilience gain: +11
   Difficulty: low
   Overlapping skills: Mathematics, Reading Comprehension, Writing
   Skills to develop: Coordination, Service Orientation
```

## Manual Transition Analysis (Professional+)

Without Enterprise tier, you can build transition analysis using keystone skills:

```python
def find_transitions_manual(source_soc: str, client, min_similarity: float = 0.6):
    """Find career transitions using keystone skill overlap."""
    
    # Get source job's keystone skills
    source_job = client.get_job(source_soc)
    source_skills = set(s["name"] for s in source_job.get("keystone_skills", []))
    source_resilience = source_job["scores"]["human_centric_resilience_score"]
    
    # Search for similar jobs
    search_results = client.search_jobs_semantic(
        f"careers similar to {source_job['title']}",
        limit=30
    )
    
    transitions = []
    for result in search_results["jobs"]:
        if result["soc_code"] == source_soc:
            continue
            
        target_job = client.get_job(result["soc_code"])
        target_skills = set(s["name"] for s in target_job.get("keystone_skills", []))
        target_resilience = target_job["scores"]["human_centric_resilience_score"]
        
        # Calculate Jaccard similarity
        if not target_skills:
            continue
        overlap = source_skills & target_skills
        union = source_skills | target_skills
        similarity = len(overlap) / len(union) if union else 0
        
        if similarity >= min_similarity:
            transitions.append({
                "target_soc": result["soc_code"],
                "target_title": target_job["title"],
                "skill_similarity": similarity,
                "resilience_gain": target_resilience - source_resilience,
                "overlapping_skills": list(overlap),
                "gap_skills": list(target_skills - source_skills)
            })
    
    # Sort by resilience gain
    transitions.sort(key=lambda x: x["resilience_gain"], reverse=True)
    return transitions

# Usage
transitions = find_transitions_manual("43-3031.00", client)
for t in transitions[:5]:
    print(f"{t['target_title']}: +{t['resilience_gain']:.0f} resilience, "
          f"{t['skill_similarity']:.0%} skill match")
```

## Skill Gap Analysis

Identify exactly what skills need development:

```python
# Enterprise: Use the gap analysis endpoint
gap = client.analyze_skill_gap(
    current_skills=["Mathematics", "Critical Thinking", "Reading Comprehension"],
    target_job="13-2011.00"  # Accountants
)

print(f"Skill Coverage: {gap['skill_coverage']:.0%}\n")

print("Skills to Develop (by priority):")
for skill in gap["gap_skills"]:
    print(f"  - {skill['name']} - {skill['priority']} priority")
    print(f"    AI Resilience: {skill['ai_resilience']:.0%}")

print("\nTransferable Skills:")
for skill in gap["transferable_skills"]:
    print(f"   {skill['name']}")
```

### Professional Tier Alternative

```python
def analyze_skill_gap(current_skills: list[str], target_soc: str, client):
    """Analyze skill gap for career transition."""
    
    target_job = client.get_job(target_soc)
    keystone_skills = target_job.get("keystone_skills", [])
    
    target_skill_names = {s["name"] for s in keystone_skills}
    current_skill_set = set(current_skills)
    
    overlapping = current_skill_set & target_skill_names
    gaps = target_skill_names - current_skill_set
    
    # Get gap skills with metadata
    gap_skills = [
        s for s in keystone_skills 
        if s["name"] in gaps
    ]
    # Sort by combined impact (most important first)
    gap_skills.sort(key=lambda x: x["combined_impact"], reverse=True)
    
    return {
        "coverage": len(overlapping) / len(target_skill_names) if target_skill_names else 0,
        "transferable": list(overlapping),
        "gaps": gap_skills
    }

# Usage
result = analyze_skill_gap(
    ["Programming", "Critical Thinking"],
    "15-1252.00",  # Software Developers
    client
)
print(f"Coverage: {result['coverage']:.0%}")
for gap in result["gaps"][:5]:
    print(f"  Need: {gap['name']} (AI resilience: {gap['ai_resilience']:.0f}%)")
```

## Building a Career Pathways UI

### React Component

```tsx
interface Transition {
  target_soc: string;
  target_title: string;
  skill_similarity: number;
  resilience_gain: number;
  overlapping_skills: string[];
  gap_skills: string[];
  transition_difficulty: string;
}

function CareerPathways({ sourceSoc }: { sourceSoc: string }) {
  const [transitions, setTransitions] = useState<Transition[]>([]);
  const [loading, setLoading] = useState(true);
  const [filters, setFilters] = useState({
    minResilienceGain: 0,
    maxDifficulty: 'high'
  });

  useEffect(() => {
    fetch(`/api/transitions/${sourceSoc}`)
      .then(r => r.json())
      .then(data => {
        setTransitions(data.transitions);
        setLoading(false);
      });
  }, [sourceSoc]);

  const filteredTransitions = transitions.filter(t => 
    t.resilience_gain >= filters.minResilienceGain &&
    getDifficultyLevel(t.transition_difficulty) <= getDifficultyLevel(filters.maxDifficulty)
  );

  return (
    <div className="career-pathways">
      <h2>Career Transition Options</h2>
      
      <div className="filters">
        <label>
          Minimum resilience gain:
          <input 
            type="range" 
            min="0" 
            max="30" 
            value={filters.minResilienceGain}
            onChange={e => setFilters({...filters, minResilienceGain: +e.target.value})}
          />
          <span>+{filters.minResilienceGain}</span>
        </label>
      </div>

      <div className="transitions-list">
        {filteredTransitions.map(t => (
          <TransitionCard key={t.target_soc} transition={t} />
        ))}
      </div>
    </div>
  );
}

function TransitionCard({ transition }: { transition: Transition }) {
  const difficultyColors = {
    low: 'bg-green-100 text-green-800',
    medium: 'bg-yellow-100 text-yellow-800',
    high: 'bg-red-100 text-red-800'
  };

  return (
    <div className="transition-card border rounded-lg p-4 mb-4">
      <div className="flex justify-between items-start">
        <div>
          <h3 className="text-lg font-semibold">{transition.target_title}</h3>
          <div className="flex gap-4 mt-2 text-sm">
            <span className="text-green-600">
              +{transition.resilience_gain.toFixed(0)} resilience
            </span>
            <span>
              {(transition.skill_similarity * 100).toFixed(0)}% skill match
            </span>
            <span className={`px-2 py-1 rounded ${difficultyColors[transition.transition_difficulty]}`}>
              {transition.transition_difficulty} difficulty
            </span>
          </div>
        </div>
      </div>

      <div className="mt-4 grid grid-cols-2 gap-4">
        <div>
          <h4 className="font-medium text-sm text-gray-600">Skills You Have</h4>
          <ul className="mt-1">
            {transition.overlapping_skills.slice(0, 4).map(skill => (
              <li key={skill} className="text-sm text-green-700"> {skill}</li>
            ))}
          </ul>
        </div>
        <div>
          <h4 className="font-medium text-sm text-gray-600">Skills to Develop</h4>
          <ul className="mt-1">
            {transition.gap_skills.slice(0, 4).map(skill => (
              <li key={skill} className="text-sm text-orange-700">-> {skill}</li>
            ))}
          </ul>
        </div>
      </div>

      <a 
        href={`/jobs/${transition.target_soc}`}
        className="mt-4 inline-block text-blue-600 hover:underline"
      >
        View full job profile ->
      </a>
    </div>
  );
}
```

## Regional Transition Analysis

Combine transitions with regional data:

```python
def find_regional_transitions(source_soc: str, msa_code: str, client):
    """Find transitions available in a specific region."""
    
    # Get transitions
    transitions = client.find_transitions(source_soc, max_results=20)
    
    # Get regional employment data
    region = client.get_region(msa_code, include_jobs=True)
    regional_socs = {j["soc_code"] for j in region.get("top_resilient_jobs", [])}
    
    # Filter to jobs available in region
    regional_transitions = [
        t for t in transitions["transitions"]
        if t["target_soc"] in regional_socs
    ]
    
    return regional_transitions

# Find transitions available in Los Angeles
la_transitions = find_regional_transitions("43-3031.00", "31080", client)
print(f"Found {len(la_transitions)} transitions available in LA metro")
```

## Transition Difficulty Factors

Understanding difficulty levels:

| Difficulty | Meaning                | Typical Characteristics           |
| ---------- | ---------------------- | --------------------------------- |
| **Low**    | Minimal retraining     | >85% skill overlap, same industry |
| **Medium** | Moderate development   | 70-85% overlap, related field     |
| **High**   | Significant investment | <70% overlap, different domain    |

```python
def explain_difficulty(transition):
    """Generate explanation for transition difficulty."""
    similarity = transition["skill_similarity"]
    gaps = len(transition["gap_skills"])
    
    if transition["transition_difficulty"] == "low":
        return (f"This transition leverages {similarity:.0%} of your existing skills. "
               f"You'd need to develop {gaps} new skills, primarily through on-the-job learning.")
    elif transition["transition_difficulty"] == "medium":
        return (f"This transition uses {similarity:.0%} of your skills. "
               f"You'd need to develop {gaps} new skills, possibly requiring "
               f"certification or coursework.")
    else:
        return (f"This is a significant career change with {similarity:.0%} skill overlap. "
               f"You'd need to develop {gaps} new skills, likely requiring "
               f"formal education or extensive training.")
```

## Next Steps

* [Regional Analysis](/guides/regional-analysis.md) - See where transitions are available
* [Custom Scoring](/guides/custom-scoring.md) - Weight factors for your specific needs
* [API Reference: Transitions](/api-reference/assessments.md#post-jobstransitions) - Full endpoint docs


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.maidenlabs.tools/guides/career-transitions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.