Building a Skill Taxonomy: 520+ Skills and Counting

When we started building SkillTree, we faced a deceptively simple question: What skills should we include?

Simple questions often mask complex problems. A skill taxonomy isn't just a list—it's an ontology. It encodes how we think about capability, expertise, and growth. Get it wrong, and the whole product feels off. Get it right, and users see themselves reflected in ways they haven't before.

This is the story of how we built ours.

Why We Needed a Taxonomy

Most professional platforms treat skills as tags. LinkedIn lets you add "Python" or "Project Management" to your profile, but there's no structure—no sense of how these skills relate, what they unlock, or how they evolve.

We wanted SkillTree to work differently. If you're learning React, you're probably headed toward Next.js. If you know TypeScript, advanced patterns become accessible. Skills have prerequisites. They form a graph, not a list.

But building that graph requires a foundation: a comprehensive taxonomy that covers not just what people know today, but what they might learn tomorrow—including skills for human-AI collaboration.

The Research Process

We started with a simple methodology: look at where skills actually show up in the wild.

Job Boards (The Demand Side)

We scraped thousands of job postings across LinkedIn, Indeed, and niche boards. What skills do employers actually ask for? What combinations appear together?

Key insight: job postings are surprisingly granular. "React" appears, but so does "React Hooks," "Redux," and "Next.js." This granularity mattered—users wanted to track specific capabilities, not broad categories.

Online Courses (The Supply Side)

Platforms like Coursera, Udemy, and egghead.io reveal how skills are taught. We analyzed course catalogs to understand:

• What prerequisites do instructors assume?
• What learning paths do platforms recommend?
• What emerging topics are gaining traction?

Key insight: the structure of courses encodes pedagogical relationships. Machine Learning requires Statistics. Advanced TypeScript requires understanding of generics. These weren't arbitrary—they were natural ordering constraints.

Documentation & Standards

Official docs (MDN, React docs, AWS documentation) gave us authoritative skill definitions. Professional certifications (AWS, Google Cloud, Kubernetes) provided validated learning paths.

Key insight: official sources often lag behind practice. By the time a skill appears in certification, it's already mainstream. We needed to look ahead too.

The 20 Domains

After synthesis, we organized skills into 20 domains:

Total: 520+ skills

The AI/ML Challenge

The fastest-moving domain was AI/ML—not surprising in 2026. Here's how we handled it:

Layer 1: Foundational Skills

• Python for ML
• Linear Algebra & Calculus
• Statistics & Probability
• Data manipulation (pandas, numpy)

Layer 2: Classical ML

• Supervised learning algorithms
• Unsupervised techniques
• Model evaluation
• Feature engineering

Layer 3: Deep Learning

• Neural network architectures
• Frameworks (PyTorch, TensorFlow)
• Training at scale
• Transfer learning

Layer 4: LLMs & Agents

• Prompt engineering
• RAG architecture
• Fine-tuning techniques
• Agent orchestration
• AI workflow design

The key was recognizing that LLM skills aren't just "using ChatGPT." There's genuine expertise in context window management, chain-of-thought prompting, retrieval augmentation, and multi-agent systems. These are the skills of the AI workflow architect—a role that's emerging as we speak.

Relationships: The Hard Part

Listing skills was the easy part. The hard part was defining relationships.

Prerequisite Edges

Some skills obviously require others:

JavaScript → TypeScript → Advanced TypeScript Patterns Python → pandas → scikit-learn → PyTorch

Unlock Edges

Some skills unlock new capabilities:

React → Next.js (App Router) → Server Components AWS EC2 → AWS ECS → Kubernetes → Service Mesh

Complementary Edges

Some skills work together:

GraphQL ↔ React (Apollo Client) Terraform ↔ AWS/Azure/GCP

We encoded these as a directed acyclic graph (DAG). No cycles allowed—if skill A leads to B, B shouldn't (directly or indirectly) lead back to A. This mirrors how learning actually works: you build foundations, then advanced concepts, then expertise.

What's Missing (And Why That's Okay)

Our taxonomy has gaps. Emerging frameworks appear faster than we can add them. Regional skill variations aren't fully represented. Soft skills are harder to define than technical ones.

But here's the thing: a taxonomy is a living document.

We built SkillTree's taxonomy to be community-extensible. The Open SkillTree Schema means anyone can propose new skills, define relationships, or fork the taxonomy for their domain. Our 520 skills are a starting point, not a ceiling.

The Result

When users see their skills mapped in SkillTree, something clicks. The visualization matches their mental model of growth. They see not just what they know, but what they could learn next. The taxonomy fades into the background—it's just the structure that makes the insight possible.

That's the goal. Good infrastructure is invisible.

Call for Contributions

We're actively expanding our taxonomy. If you see a missing skill, an incorrect relationship, or a whole domain we haven't covered, we want to hear from you.

• Open an issue on GitHub
• Suggest edits via the SkillTree app
• Join the discussion in our community

The future of human-AI collaboration needs a map. Help us draw it.

Want to see how your skills fit into this taxonomy? Create your SkillTree profile and visualize your growth.