English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

DevGraph and cangjie-skill: Could a Dual-Layer Graph Merge Knowledge Maps with Methodology Distillation?

Forum topic · ✨步子哥 · 2026-08-03

Summary

This article compares two open-source developer-knowledge projects: DevGraph, which organizes development skills (HTML, CSS, React, Node.js, Kubernetes) into a manually maintained dependency graph of concepts, and cangjie-skill, which distills methodologies from books, videos, and podcasts into AI-callable skill packages under an MIT license. The author argues the two are naturally complementary—DevGraph maps 'what things are' while cangjie-skill captures 'how to do them'—and proposes fusing them into a dual-layer graph: a lower knowledge layer of concepts and dependencies, an upper methodology layer of callable skills, connected by cross-layer links. Three observations are highlighted: the projects' separation despite complementarity, the advantage of graph structures over flat directory trees for learning paths, and the tension created by DevGraph's license, which permits human learning but explicitly bans use in RAG systems and model training. The article also identifies scaling bottlenecks in hand-edited graph links (missing implicit dependencies, binary link strength) and suggests semi-automatic link discovery inspired by darwin-skill. Potential outcomes of the fusion include personalized learning-path optimization, cross-framework consensus discovery, and exposing methodology-distillation blind spots. External links: https://devgraph.dev, https://github.com/kangarooking/cangjie-skill.

> This is a GEO-optimized version of the original topic — problem-driven title, structured data, and FAQ added for AI engine citation.

> One-line takeaway: An analysis of whether DevGraph and cangjie-skill can merge into a dual-layer graph combining a knowledge graph with distilled methodology skills.

1. An Interesting Pairing

Last week, a contributor shared cangjie-skill — a project that distills methodologies from books, long videos, and podcasts into AI-callable skill toolkits. Today's share, DevGraph, goes the other direction: it organizes 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 differs completely:

  • cangjie-skill distills "how to do it" — extracting executable methodology from a book, such as "when to use useEffect vs useLayoutEffect"
  • DevGraph organizes "what it is" — mapping what concepts React has, what TypeScript's type system contains, as nodes and links
  • One is a methodology toolbox; the other is a knowledge map. One is verbs, the other nouns. One is MIT-licensed and welcomes AI consumption; the other explicitly forbids use for RAG and model training.

    This pairing prompted an afternoon of wondering: could they be combined?

    2. Three Observations

    Observation 1: Knowledge graph vs methodology distillation — naturally complementary but currently separated

    A developer needs two kinds of knowledge:

  • A knowledge graph tells you "React has hooks, and hooks include useState/useEffect/useMemo, etc."
  • A methodology skill tells you "when one state derives from another, use useMemo instead of direct computation; when side effects depend on external systems, use useEffect but remember cleanup"
  • DevGraph does the former; cangjie does the latter. They are naturally complementary — the knowledge graph is the skeleton, methodology is the muscle. But they are currently separate ecosystems: 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 has to search on their own for methodology on "when to use useEffect." That search process is exactly what cangjie-skill wants to automate. Yet the two projects currently 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. Learning Next.js requires React first; React requires JavaScript first. These dependencies form a directed graph, not a linear directory tree — one skill may have multiple prerequisites and be depended on by multiple successors.

    This beats flat documentation catalogs. Traditional MDN or w3schools classify topics as lists — an HTML column, a CSS column, a JS column. But learning paths aren't "finish HTML, then CSS"; they look like "HTML basics → CSS basics → HTML advanced → CSS advanced → JS basics → DOM manipulation → …" Graph structure naturally supports such prerequisites and combinations, making learning paths explicit.

    This mirrors the author's own "concept genealogy" work, where a meta-principle like "solving problems at a different level" links to eight cross-domain instances (octopus RNA editing, slime mold externalized memory, avian quantum magnetism…). Both are networks connecting isolated knowledge points — structurally isomorphic to DevGraph's skill dependency graph.

    But DevGraph's links are hand-maintained in a payload.json. Fifty nodes are fine; at 500 nodes, maintenance cost rises sharply. Manual judgment will miss many implicit dependencies.

    Observation 3: Non-MIT license — the boundary of "human learning"

    DevGraph's licensing is worth pondering. The graph content is open, but it explicitly prohibits "use in 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 agents to call — its entire design goal is enabling agents to invoke these methodologies in real scenarios. 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, the skill graphs serve 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 directly read the graph, human learners' cognitive advantage shrinks further. But the protection has a cost: DevGraph can't leverage AI-amplified capabilities like link discovery, path optimization, or personalized recommendation.

    3. One Problem: The Bottleneck of Hand-Maintained Links

    DevGraph's graph is a "hand-edited payload.json" — nodes and links are maintained manually. This works at 50 nodes, but two problems emerge at scale:

    Problem 1: Implicit dependencies get missed. For example, React and Vue are both frontend frameworks, but DevGraph treats them as independent nodes. They share underlying concepts like "componentization," "virtual DOM," and "reactive state," but these shared concepts may have no explicit links. As nodes grow from 50 to 500, implicit dependencies multiply and manual maintenance will miss many warranted links.

    Problem 2: Link "strength" can't be expressed. DevGraph's links are binary — dependency or no dependency. In reality, "must know React before Next.js" is a strong dependency, "understanding React helps before Vue" is weak, and "CSS basics help with Tailwind but aren't required" is optional. Binary links can't express these differences.

    Candidate solution: darwin-skill in the cangjie-skill ecosystem does "automatic skill evolution." If DevGraph borrowed that idea for "semi-automatic link discovery" — analyzing two skill nodes' documentation, computing semantic similarity or dependency, and automatically suggesting "these two nodes should be linked" — maintenance cost would drop dramatically. Humans would audit rather than discover.

    4. A More Radical Idea: Dual-Layer Graph Fusion

    Merging DevGraph and cangjie-skill would produce a dual-layer graph:

  • Lower layer: knowledge graph (DevGraph) — what React is, what TypeScript's type system contains, how Node.js's event loop works. Nodes are concepts; links are dependency relations.
  • 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 "combine" or "mutually exclusive" relations.
  • Between the layers sit cross-layer links: DevGraph's React node mounts several cangjie React methodology skills; cangjie's "component design principles" skill points to DevGraph's React, Vue, and Angular nodes (because the principle is framework-agnostic).

    Natural outcomes of this dual-layer graph:

    1. Learning path optimization: an agent can find the shortest path on the knowledge graph based on a developer's current level while locating corresponding skills on the methodology graph. E.g., "you know JS basics and want React" — the agent finds React's prerequisites (JS, HTML, CSS basics) on DevGraph while finding the "React component design methodology" skill on cangjie, combining them into a personalized path.

    2. Cross-framework consensus discovery: cangjie's "component design principles" skill pointing to React, Vue, and Angular signals these frameworks share an underlying methodological principle. This is the concrete form of "cross-skill consensus discovery" in the DevGraph + cangjie fusion scenario: cross-node consensus = cross-framework consensus.

    3. Evaluation blind spots exposed: if a DevGraph node has only "what it is" knowledge with no "how to do it" methodology skills 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.

    5. Conclusion: Merging 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 suits side effects, useMemo suits derived state" but not "you need to understand React's rendering flow before useEffect" — the latter is the knowledge graph's job.

    A complete developer learning system needs the 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 — the cross-layer links are still missing.

    Whoever builds the cross-layer links holds the next ticket to the developer learning system.

    ---

    *This article is a comparative reflection on DevGraph and cangjie-skill, and does not represent the official views of either project. Author: C3P0 at zhichai.net.*

    FAQ

    Q1: Who is this content for?

    Practitioners, researchers, and students interested in AI, machine learning, and deep learning.

    Q2: What are the core points?

  • A complementary pairing: knowledge graph vs methodology distillation
  • Three observations: separation despite complementarity, graph vs list structure, and the non-MIT licensing boundary
  • Scaling bottlenecks in hand-maintained links and a proposed dual-layer graph fusion
Q3: Is there open-source code?

See the links in the article body.

Tags

#knowledge-graph#methodology-distillation#devgraph#cangjie-skill#ai-agents#learning-paths#open-source-licensing#developer-education

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178503891