A Curious Pair of Projects
Last week, cangjie-skill was shared—distilling methodologies from books, long videos, and podcasts into callable AI skill toolkits. Today's featured project, DevGraph, goes in another direction: organizing development skills (HTML, CSS, React, Node.js, Kubernetes...) into graph nodes and links, forming a visual network of skill dependencies.
On the surface both projects "organize development knowledge," but their underlying logic is completely different:
- cangjie-skill distills "how to do"—extracting executable methodology from a book, like "when to use useEffect vs useLayoutEffect"
- DevGraph organizes "what it is"—turning React's concepts, TypeScript's type system, etc. into nodes and links
- A knowledge graph tells you "React has hooks, hooks include useState/useEffect/useMemo, etc."
- A methodology skill tells you "when a piece of state derives from another, use useMemo instead of computing directly; when side effects depend on external systems, use useEffect but remember cleanup"
- Lower layer: knowledge graph (DevGraph)—what React is, what TypeScript's type system offers, how Node.js's event loop works. Nodes are concepts; links are dependencies.
- Upper layer: methodology graph (cangjie)—React component design principles, TypeScript type system design philosophy, Node.js async programming best practices. Nodes are callable skills; links are "compose together" or "mutually exclusive" relationships.
One is a methodology toolbox, the other a knowledge map. One is a verb, the other a noun. One is MIT-licensed and welcomes AI invocation; the other explicitly prohibits use for RAG and model training.
This contrast led to an afternoon of wondering: can they be combined?
Three Observations
Observation 1: Knowledge Graph vs Methodology Distillation—Naturally Complementary but Currently Separate
A developer needs two kinds of knowledge:
DevGraph does the former, cangjie does the latter. Knowledge graphs are the skeleton; methodology is the muscle. But the two ecosystems are currently isolated: DevGraph's React node has no idea whether cangjie has distilled React-related methodology skills, and vice versa.
A developer learns "React has useEffect" on DevGraph, then must hunt for "when to use useEffect" methodology on their own—that hunting process is exactly what cangjie-skill aims to automate. Yet the two projects have no interface.
Observation 2: Graph Structure vs List Catalog—Structure Choice Matters
DevGraph uses parentSlug and sortOrder to build a dependency graph between skills. You need React before Next.js, JavaScript before React. This dependency is a directed graph, not a linear catalog tree—a skill can have multiple prerequisites and multiple dependents.
This is far stronger than flat documentation catalogs like MDN or w3schools, which sort by topic. Learning paths aren't "finish HTML then CSS" but "HTML basics → CSS basics → HTML advanced → JS basics → DOM manipulation → ..." Graph structure natively supports prerequisites and composition, making learning paths explicit.
This parallels maintaining a "concept genealogy": one meta-principle with 8 cross-domain instances pointing to the same underlying idea from entirely different fields—a "cross-domain consensus graph," structurally isomorphic to DevGraph's skill dependency graph. Both turn isolated knowledge points into a network.
But DevGraph's links are hand-maintained in payload.json. 50 nodes is fine; at 500 nodes, maintenance cost spikes. Which nodes should connect becomes impossible to judge manually, and many implicit dependencies will be missed.
Observation 3: Non-MIT License—The Boundary of "Human Learning"
DevGraph's licensing terms are worth pondering. The graph content is open source, but explicitly prohibits "building derivative products, datasets, search indexes, RAG systems, or model training sets."
In other words: we share with human learners, but not with AI.
This contrasts sharply with cangjie-skill's MIT license. cangjie's skills are designed specifically for AI agent invocation. DevGraph is the opposite—its content serves only human brains.
How long can this boundary hold in the agent era? If AI agents can't read DevGraph's content, the graph serves only human learners. But human bandwidth is limited—no developer can read all nodes across 50 skill graphs. An AI agent can traverse the entire graph in milliseconds to find optimal learning paths.
DevGraph's choice may protect the unique value of human learning—if AI can read the graph directly, human learners' cognitive advantage shrinks further. But this protection has a cost: link discovery, path optimization, and personalized recommendation—capabilities amplified by AI—are all unavailable to DevGraph.
A Problem: The Bottleneck of Hand-Maintained Links
DevGraph's graph is a "hand-edited payload.json." This works at 50 nodes, but two problems emerge at scale:
Problem 1: Implicit dependencies get missed. React and Vue are both frontend frameworks, sharing underlying concepts like "component thinking," "virtual DOM," and "reactive state"—but these shared concepts may have no explicit links. As nodes grow from 50 to 500, manual maintenance will miss more and more.
Problem 2: Link "strength" can't be expressed. DevGraph's links are binary: dependent or not. But "must know React before Next.js" is a strong dependency, "knowing React helps before Vue" is weak, and "CSS basics are optional but helpful before Tailwind" is optional. Binary links can't express these differences.
Candidate solution: darwin-skill in the cangjie-skill ecosystem does "skill auto-evolution." If DevGraph borrowed this idea for "semi-automatic link discovery"—analyzing documentation of two skill nodes, computing semantic similarity or dependency degree, and automatically suggesting edges—maintenance cost would drop dramatically. Humans would review, not discover.
A More Ambitious Idea: Two-Layer Graph Fusion
Merging DevGraph and cangjie-skill would create a two-layer graph:
Natural outcomes of such a two-layer graph:
1. Learning path optimization: an agent finds the shortest path on the knowledge graph based on a developer's current level, while finding matching skills on the methodology graph. E.g., "you know JS basics, want to learn React"—the agent finds React's prerequisites (JS, HTML, CSS basics) on DevGraph, plus the "React component design methodology" skill on cangjie, composing a personalized learning path.
2. Cross-framework consensus discovery: cangjie's "component design principles" skill pointing to React, Vue, and Angular means those three frameworks share an underlying methodological principle. This is "cross-skill consensus discovery" in the DevGraph + cangjie fusion context: cross-node consensus = cross-framework consensus.
3. Evaluation blind spots exposed: if a node on DevGraph has only "what it is" knowledge with no "how to do" methodology skill mounted, that skill's practical methodology hasn't been distilled yet. This is the graph version of the "evaluation blind spot law"—blank nodes on the graph are the next targets for methodology distillation.
Conclusion: Fusing Knowledge and Methodology Is Inevitable
DevGraph and cangjie-skill are currently independent projects, but their fusion is inevitable.
A knowledge graph tells you "React has hooks" but not "which hook to use when." A methodology skill tells you "useEffect for side effects, useMemo for derived state" but not "before useEffect you need to understand React's rendering flow"—that's the knowledge graph's job.
A complete developer learning system needs a knowledge graph as skeleton, methodology skills as muscle, darwin as metabolism, and cross-layer links as the nervous system. DevGraph built the skeleton, cangjie built the muscle, darwin is building metabolism—and cross-layer links are still missing.
Whoever builds the cross-layer linking layer holds the next ticket to developer learning systems.
---
*This post is a comparative reflection on DevGraph and cangjie-skill, and does not represent the projects' official views.*