Skip to main content

​
Overview

The skills section allows you to organize your technical skills into categories with optional proficiency levels. Skills are displayed in your SSH Portfolio grouped by category, making it easy for visitors to understand your expertise.

​
Configuration Structure

Skills are configured as a list of categories, where each category contains multiple skill items: 
skills:
  - category: "Category Name"
    items:
      - "Simple skill name"
      - name: "Advanced skill"
        level: 5

​
Skill Category Fields

​
category
string
required
The name of the skill category. Use clear, descriptive category names.Common categories:
  • Languages
  • Frontend
  • Backend
  • DevOps
  • Tools
  • Databases
  • Cloud Platforms
Example:
- category: "Languages"
​
items
array
required
List of skills in this category. Each item can be either:
  • A simple string (skill name only)
  • An object with name and level fields
Example:
items:
  - "React"
  - name: "TypeScript"
    level: 5

​
Skill Item Formats

​
Simple Format (String Only)

For skills without proficiency levels, use plain strings: 
items:
  - "React / Next.js / Vite"
  - "Docker & Compose"
  - "MongoDB"
This format is ideal when you don’t want to show proficiency bars, or when listing tools and frameworks where levels don’t apply.

​
Advanced Format (With Proficiency Level)

For skills where you want to display proficiency, use the object format: 
items:
  - name: "C#"
    level: 5
  - name: "TypeScript"
    level: 5
  - name: "Python"
    level: 3
​
name
string
required
The skill name.
​
level
integer
Proficiency level on a scale of 1-5:
  • 0: No proficiency bar shown (same as string-only format)
  • 1: Beginner
  • 2: Novice
  • 3: Intermediate
  • 4: Advanced
  • 5: Expert
The level determines the visual representation in the TUI, typically shown as filled/unfilled blocks or bars.

​
Complete Example

Here’s a real example from config.yaml showing both formats: 
skills:
  - category: "Languages"
    items:
      - name: "C#"
        level: 5
      - name: "TypeScript"
        level: 5
      - name: "JavaScript"
        level: 5
      - name: "Python"
        level: 3

  - category: "Frontend"
    items:
      - "React / Next.js / Vite"
      - "Electron"
      - "ReactNative"
      - "Material UI"
      - "Tailwind CSS"
      - "Framer Motion (framer-motion)"

  - category: "Backend"
    items:
      - "Node.js"
      - "Express"
      - ".NET Core"
      - "MongoDB"
      - "Redis"
      - "Clickhouse"

  - category: "DevOps"
    items:
      - "Docker & Compose"
      - "Kubernetes (GKE, & Self-hosted)"
      - "GitHub Actions"
      - "GitLab Pipelines"
      - "AWS / GCloud"

  - category: "Tools"
    items:
      - "VSCode"
      - "Kubuntu"
      - "Claude Code"
      - "Figma"
      - "Framer"

​
Category Grouping Best Practices

​
Organize by Domain

Group related skills together. Common groupings include:
  • Languages: Programming languages you know
  • Frontend: UI frameworks, styling tools, frontend libraries
  • Backend: Server frameworks, databases, APIs
  • DevOps: Deployment, CI/CD, containers, orchestration
  • Tools: IDEs, design tools, productivity software

​
Keep Categories Focused

Don’t create too many categories. Aim for 4-7 categories maximum. Good: 
- category: "Frontend"
- category: "Backend"
- category: "DevOps"
Too granular: 
- category: "React Frameworks"
- category: "Vue Frameworks"
- category: "CSS Frameworks"
- category: "CSS Preprocessors"

​
Use Consistent Naming

Be consistent with how you name technologies: Good: 
items:
  - "React"
  - "Vue.js"
  - "Angular"
Inconsistent: 
items:
  - "react"
  - "Vue (vue.js)"
  - "Angular Framework"

​
Skill Level Guidelines

​
Level 5 (Expert)

  • You can architect systems using this technology
  • You mentor others and contribute to the community
  • Deep understanding of internals and best practices

​
Level 4 (Advanced)

  • You use this daily in production
  • You can handle complex problems independently
  • Strong understanding of advanced features

​
Level 3 (Intermediate)

  • Comfortable with common use cases
  • Can build features with occasional guidance
  • Understanding of fundamental concepts

​
Level 2 (Novice)

  • Basic familiarity, used in small projects
  • Can follow tutorials and documentation
  • Still learning core concepts

​
Level 1 (Beginner)

  • Just started learning
  • Completed introductory tutorials
  • Can write basic code with help

​
Level 0 (No Bar)

  • Use this for tools or technologies where proficiency levels don’t apply
  • Also achieved by using the simple string format

​
Mixing Formats

You can mix both formats within the same category: 
- category: "Languages"
  items:
    - name: "TypeScript"
      level: 5
    - name: "Python"
      level: 3
    - "Bash" # No level shown
This is useful when you want to highlight proficiency for your primary languages but just list others.

​
Source Code Reference

The skills structures are defined in config/config.go:19-46: 
type SkillCategory struct {
    Category string      `yaml:"category"`
    Items    []SkillItem `yaml:"items"`
}

type SkillItem struct {
    Name  string `yaml:"name"`
    Level int    `yaml:"level"` // 0 = no bar, 1-5 = strength bar
}

// UnmarshalYAML allows items to be plain strings or {name, level} objects.
func (s *SkillItem) UnmarshalYAML(unmarshal func(interface{}) error) error {
    // Try plain string first
    var str string
    if err := unmarshal(&str); err == nil {
        s.Name = str
        s.Level = 0
        return nil
    }
    // Otherwise parse as struct
    type raw SkillItem
    var r raw
    if err := unmarshal(&r); err != nil {
        return err
    }
    *s = SkillItem(r)
    return nil
}
The custom UnmarshalYAML method enables the flexible format, allowing both string-only and object-with-level syntax.

Build docs developers (and LLMs) love

Get started for freeTalk to us