Orchestrator/privat/CV/README.md

Personal Knowledge Base

A file-based personal knowledge graph that stores structured professional information in YAML, enabling tailored CV generation, interview-based knowledge collection, speaker introductions, and iterative review workflows.

The file system is the database. No build step, no server, no compilation required. Git provides version history and deployment.

Directory Structure

project-root/
├── kb/                        # Knowledge base data (YAML entity files)
│   ├── profiles/              # Person profile entities
│   ├── experiences/           # Work experience entities
│   ├── skills/                # Skill entities
│   ├── organizations/         # Organization entities
│   ├── projects/              # Project entities
│   ├── certifications/        # Certification entities
│   ├── tandems/               # Job sharing tandem entities
│   └── graph-index.yaml       # Central index of all entities and relationships
├── templates/                 # Document generation templates
│   ├── cv-templates/          # CV layout templates (Markdown)
│   └── intro-templates/       # Speaker introduction templates
├── output/                    # Generated documents (gitignored or committed)
│   ├── cvs/                   # Generated CV files
│   └── intros/                # Generated introduction files
├── sources/                   # Imported source documents (PDFs, DOCX)
├── src/                       # TypeScript validation and logic
├── .kiro/
│   ├── skills/                # Kiro agent skills
│   │   ├── interview-collect/ # Knowledge collection via interview
│   │   ├── cv-generate/       # Tailored CV generation
│   │   ├── talk-intro/        # Speaker introduction generation
│   │   └── kb-review/         # Knowledge base review and maintenance
│   └── steering/              # Kiro steering files (conventions)
└── README.md

Directory Purposes

Directory	Purpose
kb/	Core data store. All entities stored as individual YAML files, one file per entity.
kb/profiles/	Person profiles with name, contact, summary, education, languages, and entity references.
kb/experiences/	Work experiences with title, organization, dates, description, achievements, and skills used.
kb/skills/	Skills with name, category, proficiency level, and years of experience.
kb/organizations/	Organizations with name, industry, and optional parent organization.
kb/projects/	Projects with description, organization, dates, skills used, and persons involved.
kb/certifications/	Certifications with issuer, date, and optional expiry.
kb/tandems/	Job sharing tandem definitions linking two partners with shared vision and collaboration model.
templates/	Markdown templates used by generation skills for consistent document formatting.
output/	Generated documents (CVs, introductions) produced by Kiro skills.
sources/	Imported source documents (PDFs, DOCX) used as reference for data extraction.
src/	TypeScript validation logic and utilities for schema enforcement and testing.

Kiro Skills

Four Kiro skills automate common workflows. Activate them through Kiro's skill system.

interview-collect

Purpose: Conducts focused interview sessions to collect or update knowledge base data.

How to activate: Use the /interview-collect command or ask Kiro to run an interview session.

What it does:

• Identifies gaps in existing profiles (missing required and optional attributes)
• Asks focused questions — maximum 10 per session, covering one topic area
• Writes collected data to the appropriate entity YAML files
• Updates the graph index with new entities and relationships
• Detects conflicts with existing data and asks for resolution

cv-generate

Purpose: Generates tailored CVs from knowledge base data matched against a job posting.

How to activate: Use the /cv-generate command or ask Kiro to generate a CV, providing a job posting.

What it does:

• Analyzes job posting requirements
• Selects relevant experiences, skills, and projects from the knowledge base
• Generates individual CVs emphasizing matching qualifications
• Generates tandem CVs (combined + 2 individual) for job sharing applications
• Outputs Markdown files in output/cvs/
• Never fabricates content — only uses data present in the knowledge base

talk-intro

Purpose: Generates speaker introductions for talks and events.

How to activate: Use the /talk-intro command or ask Kiro to generate a speaker introduction, providing a talk topic and event context.

What it does:

• Produces three length variants: short (2-3 sentences), medium (paragraph), long (multi-paragraph)
• Adapts tone to event context (technical conference, business meeting, academic setting)
• Highlights relevant expertise from the person profile based on the talk topic
• Outputs Markdown files in output/intros/

kb-review

Purpose: Initiates review sessions for knowledge base maintenance and enhancement.

How to activate: Use the /kb-review command or ask Kiro to review the knowledge base.

What it does:

• Calculates completeness scores per profile (filled attributes / total attributes)
• Identifies stale information based on last-modified dates
• Presents a prioritized list of areas needing updates
• Suggests relationship additions for graph consistency
• Recommends topics for the next interview session

Entity Types and Schemas

All entity files use YAML format and share a common header:

id: <kebab-case-unique-id>
type: <entity-type>
created: <ISO-8601 date>
modified: <ISO-8601 date>

Person Profile

Location: kb/profiles/<person-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always person
name.first	string	yes	First name
name.last	string	yes	Last name
name.display	string	yes	Display name
contact	object	no	Email, LinkedIn, location
summary	string	no	Professional summary
languages	list	no	Languages with proficiency level
education	list	no	Education history entries
skills	list	no	References to skill entity IDs
experiences	list	no	References to experience entity IDs
certifications	list	no	References to certification entity IDs
publications	list	no	Publications list

Experience

Location: kb/experiences/<experience-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always experience
title	string	yes	Job title or role name
organization	string	yes	Reference to organization entity ID
start	date	yes	Start date (YYYY-MM)
end	date	no	End date (null = current)
description	string	no	Role description
achievements	list	no	List of achievements
skills-used	list	no	References to skill entity IDs
projects	list	no	References to project entity IDs

Skill

Location: kb/skills/<skill-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always skill
name	string	yes	Display name
category	string	yes	One of: programming-language, framework, methodology, soft-skill, domain
level	string	yes	One of: beginner, intermediate, advanced, expert
years	number	no	Years of experience
context	string	no	Notes on how/where the skill was developed

Organization

Location: kb/organizations/<org-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always organization
name	string	yes	Organization name
industry	string	yes	Industry sector
parent	string	no	Reference to parent organization entity ID
website	string	no	Organization website

Project

Location: kb/projects/<project-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always project
name	string	yes	Project name
description	string	no	Project description
organization	string	yes	Reference to organization entity ID
start	date	yes	Start date
end	date	no	End date
skills-used	list	no	References to skill entity IDs
persons	list	no	References to person entity IDs

Certification

Location: kb/certifications/<cert-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always certification
name	string	yes	Certification name
issuer	string	yes	Issuing organization
date	date	yes	Date obtained
expires	date	no	Expiry date
person	string	yes	Reference to person entity ID

Tandem (Job Sharing)

Location: kb/tandems/<tandem-id>.yaml

Field	Type	Required	Description
id	string	yes	Kebab-case unique identifier
type	string	yes	Always tandem
partners	list	yes	Exactly two person entity ID references
shared-vision	string	yes	Shared professional vision
complementary-skills	string	yes	How partners' skills complement each other
collaboration-model	string	yes	How work is divided and shared
combined-narrative	string	no	Joint professional narrative
joint-competencies	list	no	List of joint competency descriptions

Graph Index

Location: kb/graph-index.yaml

The central index lists all entities and their relationships:

entities:
  - id: <entity-id>
    type: <entity-type>
    name: <display-name>

relationships:
  - from: <entity-id>
    to: <entity-id>
    type: <relationship-type>
    context: <optional-reference>

Relationship types: has_skill, worked_at, collaborated_with, applied_for, partners_with

Usage Instructions

Adding Data via Interview

1. Activate the interview-collect skill
2. Specify a topic area (e.g., "my role at DB Cargo" or "my Python skills")
3. Answer the focused questions (max 10 per session)
4. Review the collected data when presented
5. Resolve any conflicts with existing data if flagged

Generating a CV

1. Activate the cv-generate skill
2. Provide the job posting (paste text or reference a file in sources/)
3. Specify whether this is an individual or tandem application
4. Review the generated CV in output/cvs/
5. For tandem applications, you'll get 3 documents: combined tandem CV + 2 individual CVs

Generating a Speaker Introduction

1. Activate the talk-intro skill
2. Provide the talk topic and event context (technical, business, or academic)
3. Review the three length variants in output/intros/

Running a Knowledge Base Review

1. Activate the kb-review skill
2. Review the completeness scores and staleness report
3. Follow up on suggested areas using the interview-collect skill

Manual Editing

Entity files are plain YAML — you can edit them directly with any text editor. After manual edits, the graph index should be rebuilt to stay consistent.

File Naming Convention

All entity files use kebab-case naming: <entity-id>.yaml

Examples: andre-knie.yaml, db-cargo-innovation-lead.yaml, aws-solutions-architect.yaml

Version Control

Git tracks all changes to the knowledge base. Every entity modification creates a meaningful diff thanks to the YAML format and one-file-per-entity pattern.

• Commit after interview sessions to capture new data
• Commit after CV generation to track output history
• Use branches for experimental changes to profiles

Technical Details

• Data format: YAML (human-readable, clean diffs, supports comments)
• Validation: TypeScript in src/ — schema validation, temporal consistency checks
• Testing: Vitest + fast-check (property-based testing)
• No build step required — the file system is the database
• No server required — Kiro skills read/write files directly