The Interview

The Interview

Status: 🚧 Beta - Core infrastructure exists, LLM integration pending

Overview

The Interview is TrajectoryOS's conversational AI-driven skill discovery and onboarding flow. It serves as the primary data ingestion mechanism for the system, transforming natural conversation into structured skill evidence that powers the Life Physics model.

Unlike traditional forms or surveys, The Interview uses adaptive questioning to uncover both explicit skills (what you know you can do) and tacit knowledge (expertise you may not recognize as valuable). The conversation dynamically adjusts based on user responses, following threads of interest while maintaining comprehensive coverage.

Purpose

The Interview solves a fundamental problem: how do you capture the complexity of human capability without overwhelming users?

Traditional approaches fail because:
- Forms are tedious: People abandon 50+ question surveys
- Self-assessment is biased: Users underestimate rare skills, overestimate common ones
- Context is lost: A skill without evidence/story lacks actionable value
- Discovery is static: No exploration of adjacent competencies

The Interview addresses these by:
1. Conversational flow: Natural dialogue, not interrogation
2. Adaptive depth: Deep dives where there's substance, quick moves when there's not
3. Story extraction: "Tell me about a time when..." captures evidence
4. Confidence modeling: Bayesian updates based on response quality
5. Dynamic routing: Discovers unexpected skills through follow-up questions

Core Concept

User Input (Natural Language)
         ↓
    [LLM Agent]
         ↓
   Structured Skill Evidence
         ↓
   Bayesian Skill Graph
         ↓
   Life Physics Model
         ↓
   Trajectory Calculations

Input: Free-form conversation (text or voice)
Process: LLM extracts skills, estimates confidence, identifies gaps
Output: Bayesian skill graph with weighted evidence
Result: Accurate trajectory calculations based on real capability

Architecture

Current Implementation (20

Endpoints (✅ Exist):
- `POST /api/interview/start` - Initialize new interview session
- `POST /api/interview/message` - Send user message, receive AI response
- `POST /api/interview/complete` - Finalize and commit skill graph

Data Models (✅ Exist):

interface InterviewSession {
  id: string;
  userId: string;
  state: 'active' | 'paused' | 'completed';
  skillsDiscovered: string[];
  conversationHistory: Message[];
  createdAt: Date;
  completedAt?: Date;
}

interface Message {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp: Date;
  extractedSkills?: SkillEvidence[];
}

interface SkillEvidence {
  skillName: string;
  confidence: number; // 0-1
  evidence: string; // User's story/example
  domain: string; // e.g., "technical", "creative", "leadership"
  relatedSkills: string[];
}

What's Missing (🔮 Planned Q1 2026):
- ❌ LLM integration (OpenAI/Anthropic)
- ❌ Prompt engineering for skill extraction
- ❌ Bayesian confidence updates
- ❌ Dynamic question generation
- ❌ Conversation summarization
- ❌ Skill taxonomy/ontology

Planned Flow

sequenceDiagram
    participant U as User
    participant API as Interview API
    participant LLM as LLM Agent
    participant DB as Database
    participant Physics as Life Physics

    U->>API: POST /interview/start
    API->>DB: Create session
    API->>LLM: Initialize with user context
    LLM-->>API: Opening question
    API-->>U: "Tell me about your work..."

    loop Conversation
        U->>API: POST /interview/message
        API->>LLM: User response + history
        LLM->>LLM: Extract skills & confidence
        LLM->>LLM: Identify follow-up areas
        LLM-->>API: Next question + skill updates
        API->>DB: Store skills & message
        API-->>U: Follow-up question
    end

    U->>API: POST /interview/complete
    API->>DB: Finalize skill graph
    API->>Physics: Recalculate trajectory
    Physics-->>API: Updated η (escape index)
    API-->>U: Summary & trajectory

Question Strategy

The Interview follows a funnel approach:

1. Opening (Broad Context)

"Tell me about your current work and what you're focused on."
"What are you trying to achieve in the next 6-12 months?"

Goal: Establish baseline, identify primary domains

2. Domain Exploration (Medium Specificity)

"You mentioned software engineering. What technologies do you work with?"
"Walk me through a recent project you're proud of."

Goal: Uncover specific skills, assess depth

3. Evidence Gathering (High Specificity)

"Tell me about a time when you had to debug a complex distributed system."
"How did you approach learning Rust when you started?"

Goal: Extract stories, calibrate confidence

4. Adjacent Discovery (Lateral Expansion)

"That project required coordinating with designers. Do you do any design work yourself?"
"You mentioned mentoring juniors. Tell me about your teaching style."

Goal: Find tacit skills, cross-domain capabilities

5. Gap Analysis (Targeted Questions)

"You haven't mentioned testing. How do you ensure code quality?"
"What areas do you feel less confident about?"

Goal: Complete skill graph, identify development areas

Bayesian Confidence Model

The Interview doesn't just collect skills—it estimates how confident it is in each skill based on evidence quality.

interface SkillNode {
  name: string;
  confidence: number; // 0-1, updated Bayesian-style
  evidenceCount: number;
  evidenceQuality: number; // Assessed by LLM
  lastUpdated: Date;
}

// Confidence Update Rule
newConfidence = (
  priorConfidence * priorWeight +
  evidenceQuality * evidenceWeight
) / (priorWeight + evidenceWeight)

Evidence Quality Factors:
- Specificity: Vague "I know React" (0.3) vs "Built 50k user app in React" (0.8)
- Recency: "10 years ago" (0.4) vs "Last month" (0.9)
- Complexity: "Hello World" (0.2) vs "Architected microservices" (0.9)
- Outcomes: "Built it" (0.5) vs "Reduced load time 80

Integration with Life Physics

Skills discovered in The Interview directly feed the Thrust (T) component of the Life Physics equation:

η = (T × A) / (G × M)

where T = Σ(skill_confidence × skill_relevance × skill_power)

Example:

// Interview discovers:
const skills = [
  { name: "TypeScript", confidence: 0.9, relevance: 1.0, power: 0.7 },
  { name: "System Design", confidence: 0.7, relevance: 0.9, power: 0.9 },
  { name: "Team Leadership", confidence: 0.6, relevance: 0.8, power: 0.8 }
];

// Calculate Thrust
const T = skills.reduce((sum, s) =>
  sum + (s.confidence * s.relevance * s.power), 0
); // = 2.28

// Feed to Life Physics
const physics = new LifePhysics({ T, A: 0.85, G: 1.2, M: 1.0 });
const eta = physics.escapeIndex(); // = 1.615 (Escaping regime)

User Experience

Entry Points

1. Onboarding (First-time users)
- Triggered on account creation
- Full 20-30 minute interview
- Builds initial skill graph

2. Periodic Updates (Every 3-6 months)
- "What's changed since we last talked?"
- 5-10 minute refresh
- Updates trajectory

3. Skill Check-ins (Event-triggered)
- User adds new goal: "Tell me about your experience with this area"
- User claims low confidence: "Let's explore what you actually know"
- 2-3 minute focused conversation

Conversational Tone

The Interview should feel like talking to a perceptive mentor, not a form:

❌ Bad (Interrogative):

"List your programming languages."
"Rate your skill in Python from 1-10."

✅ Good (Conversational):

"What languages do you work with day-to-day?"
"Tell me about something interesting you've built recently."

❌ Bad (Robotic):

"Skill: Leadership. Evidence: Y/N?"

✅ Good (Natural):

"That sounds like a complex project. Were you working solo or leading a team?"

Privacy & Control

The Interview respects user agency:

• Optional: Users can skip and manually add skills (lower confidence)
• Pausable: Save progress, resume anytime
• Editable: Review and modify extracted skills before committing
• Transparent: Show what was captured and how it affects trajectory
• Deletable: Remove skills/evidence without penalty

Technical Implementation Notes

LLM Prompt Structure (Planned)

const systemPrompt = `
You are a skill discovery agent for TrajectoryOS. Your goal is to:
1. Uncover user skills through natural conversation
2. Assess confidence based on evidence quality
3. Identify gaps and adjacent capabilities
4. Extract structured skill data from responses

Guidelines:
- Ask open-ended questions
- Follow interesting threads
- Request specific examples
- Assess depth without testing
- Be encouraging but honest
- Aim for 8-12 skills in 15-20 minutes

Output format: JSON with skills, confidence, evidence, next_question
`;

const userContext = {
  userId: "user_123",
  currentGoals: ["Learn Rust", "Build SaaS"],
  currentSkills: [], // Empty on first interview
  conversationHistory: messages
};

const response = await llm.generate({
  system: systemPrompt,
  context: userContext,
  userMessage: "I'm a software engineer..."
});

// Expected response:
{
  extractedSkills: [
    {
      name: "Software Engineering",
      confidence: 0.95,
      evidence: "Self-identified, likely primary profession"
    }
  ],
  nextQuestion: "What kind of software do you build?",
  reasoning: "Establish domain before depth"
}

Performance Targets

• Latency: < 2s per message (LLM + processing)
• Session Duration: 15-25 minutes typical
• Skills Discovered: 8-15 per session
• Dropout Rate: < 20
• User Satisfaction: > 4.2/5.0

Future Enhancements (Post-Q1 2026)

• Voice Interface: Speak instead of type
• Multi-modal: Screen share to show work
• Collaborative: Interview with references/colleagues
• Continuous: Passive skill updates from activity
• Specialized: Domain-specific question sets (engineering, design, etc.)

Why This Matters

The Interview is not just onboarding—it's the foundation of the entire system:

1. Accurate Thrust: Better skill data = better trajectory calculations
2. Personalized Guidance: System knows your real capabilities
3. Honest Baselines: Starting point for growth measurement
4. Opportunity Discovery: "You have skills for X you didn't consider"
5. Evidence-Based: Stories trump self-ratings

Without The Interview (or equivalent data ingestion), TrajectoryOS can't function—it's building a physics model with no input variables.

Current Status Summary

Overall: ~20

Related Concepts

• [Life Physics Model](./life-physics.md) - Uses skill data for Thrust calculation
• [Bayesian Skill Graph](./skill-graph.md) - Data structure for skill confidence
• [Latent State](./latent-state.md) - Temporal representation of capability
• [RAG++ (State-Based Retrieval)](./rag-plus-plus.md) - Uses interview data for context

References

• Original concept: [/docs/guides/convo.md](../guides/convo.md)
• API documentation: [/docs/api/README.md](../api/README.md#interview-endpoints)
• Service architecture: [/docs/architecture/services.md](../architecture/services.md#interview-service)
• User guide: [/docs/user-guide.md](../user-guide.md#getting-started-the-interview)