Great Sage

The Inspiration & Vision

The concept for Great Sage was born in 2022, inspired by the anime “That Time I Got Reincarnated As A Slime.” In the show, the protagonist possesses an internal AI system called the 'Great Sage' that guides him, teaches him skills, and analyzes the world to recommend his next optimal action.

I wanted to build a real-world version of this: an intelligent learning companion that maps your current knowledge base and explicitly visualizes the path to your next engineering or professional milestone.

Faced with creating a final-semester university project, a peer and I decided to bring Great Sage to life. Instead of building rigid, highly opinionated, and quickly outdated static roadmaps, we chose to architect an open-ended, crowdsourced skill graph engine that scales organically as users input their journeys.

The Architecture: Local vs. Global Graphs

To prevent the burden of manually curating an entire universe of professional skills, we engineered a relational graph topology where individual data models feed a centralized global network.

When a user onboards, they map their existing skillset. The application calculates the relative importance of each node using a dependency metric: skills that act as prerequisites for numerous other skills are rendered with a larger visual weight. As users add new skills and connections, their local updates automatically append to a global Firebase graph, expanding a universal, crowd-sourced skill tree for the entire community.

Implementation & Visualization Challenges

We divided the execution: my partner researched visualization primitives while I focused on the application architecture and UI integration. We selected D3.js to handle the heavy mathematical lifting required for a responsive, force-directed node layout.

I took the core D3 visualization matrix and heavily customized the styling, physics parameters, and boundary constraints to match a highly modern user interface.

// Conceptual rendering logic for Great Sage's D3 dynamic node sizing
const simulation = d3.forceSimulation(nodes)
  .force("link", d3.forceLink(links).id(d => d.id))
  .force("charge", d3.forceManyBody().strength(-150))
  .force("center", d3.forceCenter(width / 2, height / 2));

// Dynamic weighting: Nodes scale based on how many skills depend on them
const node = svg.append("g")
  .selectAll("circle")
  .data(nodes)
  .enter().append("circle")
  .attr("r", d => Math.max(8, d.dependencyCount * 3))
  .attr("fill", d => d.isAcquired ? "#00ffcc" : "#3377ff");

The final platform delivered a fully functional graph playground. Users could instantly map their proficiency, visually contrast their personal growth against the global "world graph," and see exactly which adjacent nodes were unlocked by their current stack.

The LLM Convergence & Future Paradigm

Shortly after we completed the initial university project, the massive emergence of Large Language Models (LLMs) changed the technical landscape. For a moment, I questioned the validity of the project—if someone could simply ask a generative AI model for a personalized learning roadmap, did a structural skill graph still need to exist?

I quickly realized that LLMs make this graph architecture more valuable, not less.

While LLMs are excellent at surface-level aggregation, they lack grounded, deterministic data structures and are prone to hallucinating paths. The true evolution of Great Sage lies in a hybrid paradigm:

• The Deterministic Layer: A crowd-sourced, community-verified D3 graph serving as the single source of truth for skill dependencies.
• The Generative Layer: An LLM orchestrator built over the graph to act as the true "Sage"—synthesizing personalized learning materials, ranking resources, and providing conversational context based on the verified graph structure.

Great Sage remains one of my definitive dream projects. It forced me to think in terms of complex data structures and open-ended scalability early in my engineering journey, and it is a system I am actively preparing to revisit.