Six months ago, we set out to answer a deceptively simple question: what skills should SkillTree track? Today, our taxonomy covers 520+ skills across 20 domains. The journey taught us more about how engineers actually learn than any framework or methodology ever could.
This is not a victory lap. It is a field report from the messy middle of building a comprehensive skill taxonomy—the mistakes we made, the assumptions we abandoned, and the principles that emerged once we stopped trying to be clever and started listening to the data.
The Wrong Way to List Skills
Most professional platforms treat skills as tags. LinkedIn lets you add "Python" or "Project Management" to your profile, but there is no structure—no sense of how these skills relate, what they unlock, or how they evolve. It is a flat list that tells you what someone has touched, not what they can actually do.
Flat lists break when AI enters the picture. Does "Python" mean writing scripts or designing distributed systems? Does "React" mean reading docs or shipping production apps at scale? A tag cannot capture that nuance. We needed something richer: a structured taxonomy that models relationships, prerequisites, and growth paths.
We started by scraping job boards, course catalogs, GitHub topics, and existing competency frameworks. We quickly realized everyone categorizes differently. LinkedIn uses "Industry Knowledge." O*NET uses occupational clusters. GitHub uses repository tags. None of them model relationships. JavaScript is not a sibling of React—it is a prerequisite.
Lesson 1: DAG, Not Tree
Our first instinct was a tree: each skill has one parent, and the world organizes neatly into hierarchies. That lasted about three days. In reality, a skill can have multiple prerequisites. CSS feeds into Tailwind CSS and Styled Components. JavaScript leads to React and Vue.
We switched to a directed acyclic graph (DAG). No cycles allowed—if skill A leads to B, B should not lead back to A. This mirrors how learning actually works: you build foundations, then advanced concepts, then expertise. Each edge carries a weight: "core prerequisite" versus "nice to have."
The DAG structure is what lets SkillTree answer questions like "What should I learn next?" or "Which skills are transferable from backend to MLOps?" A tree would have forced us into arbitrary hierarchies that do not reflect reality.
Lesson 2: Skill Inflation Is Real
Early in the process, we noticed a pattern: people claim skills they do not actually possess. "Full Stack" is not a skill—it is a role. "Kubernetes" on a resume could mean anything from "I read the docs" to "I debugged a failing pod at 2 AM during an outage."
We solved this by separating capabilities (what you can do) from technologies (what you use). A capability: "Design a RESTful API." A technology: "FastAPI." An agent can design a RESTful API without caring whether you use FastAPI or Express. This distinction is critical for AI collaboration, where the capability matters more than the specific tool.
We also built three verification layers. Self-assessment with guided rubrics prevents the Dunning-Kruger effect. Project links (GitHub repos, deployed apps) provide proof of work. Peer endorsements work best when they are specific: "Shipped a zero-downtime Kubernetes migration" is stronger than "Great at K8s."
Lesson 3: Relationships Matter More Than Labels
We spent more time on edge logic than on node labels. The taxonomy is only useful if it answers real questions. A label like "Machine Learning" is meaningless without context: does it unlock Deep Learning? Is it a prerequisite for MLOps? Does it complement Data Engineering?
We defined three relationship types. Prerequisite edges show what you need first: Python → pandas → scikit-learn. Unlock edges show what becomes possible: React → Next.js (App Router). Complementary edges show what works together: GraphQL ↔ Apollo Client.
The hard part was not the top-level domains—it was the level-3 granularity where most resumes live. "Machine Learning" → "Deep Learning" → "Transformer Architectures" → "Attention Mechanisms." That depth is where the real insight lives.
Lesson 4: Community Input Beats Top-Down Classification
We started with an expert-curated list. It was wrong. Developers disagreed on prerequisites. "Do you need TypeScript before GraphQL?" Opinions vary. "Is Docker a prerequisite for Kubernetes?" Some say yes, others say you can learn them in parallel.
Our solution: crowdsource edge votes, weight by confidence, and surface disputed edges. When the community disagrees, we show both paths. The taxonomy becomes a living consensus rather than a dictate from above. This approach aligns with how wiki-style systems achieve accuracy through iteration and collective intelligence.
Lesson 5: The Taxonomy Is Alive
New skills emerge monthly. We added "LLM Prompt Engineering" in Q1. We added "MCP (Model Context Protocol)" in Q2. The graph must version. We snapshot quarterly but allow real-time edge additions. Deprecation is as important as addition: "jQuery" is not dead, but it is a different kind of node now.
This dynamism is why static skill lists fail. A 2024 list of top skills is already obsolete in 2026. The World Economic Forum estimates that 39% of core job skills will change by 2030. A living taxonomy is not a luxury—it is a necessity.
What This Means for Your Career
A skill graph is not a vanity metric. It is a decision tool. For individuals, it finds the shortest path from "where you are" to "where you want to be." For managers, it visualizes team coverage and identifies single points of failure. For AI agents, it is a structured, machine-readable capability description.
We are releasing the Open SkillTree Schema (SKILL.md) so anyone can export their skill graph, import it into another tool, or contribute edges. The goal is simple: make skill data portable, like a resume—but structured.
The Road Ahead
520 skills is a starting point, not a ceiling. We are expanding into soft skills, creative disciplines, and cross-domain hybrids. We are refining our verification models. And we are building the APIs that will let AI agents read and reason about human skill graphs at scale.
The most exciting part is not the number. It is the pattern: 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. Good infrastructure is invisible. It just works.
Want to see how your skills fit into this taxonomy? Create your SkillTree profile and visualize your growth. Or open a PR to contribute skills or edges on GitHub.