Intuition

Entrance
Ambient Siderail, explains a component and file's place in the repo
Ambient Siderail, explains a hook and file's place in the repo
Ambient Siderail, highlights dashboard flow through multiple files (1/3)
Ambient Siderail, highlights dashboard flow through multiple files (2/3)
Ambient Siderail, highlights dashboard flow through multiple files (3/3)
Ambient Siderail, highlights new commits (1/3)
Ambient Siderail, highlights new commits (2/3)
Ambient Siderail, highlights new commits (3/3)
Choosing your expertise level
Atlas - Learning hub
Atlas - Map
Atlas - Learn Course
Atlas - Learn - Lesson - Typescript
Atlas - What's new - Catching up with Commits (1/2)
Atlas - What's new - Catching up with Commits (2/2)

Project Name & Team Members

Name: Intuition, the IDE that teaches

Team Members Kwok Zheng Feng Delfina Poernomo Jake Kee

Problem Statement and Target Users

Theme A, Statement 4: From prompt user to system architect — How might we help young people move from using AI casually to building AI-powered systems that compound their capability?

Target Users: Young people who are using AI now for coding and learning.

In our demo, we split it into:

Johnny, who vibe-coded an app he doesn't fully understand,
Chloe, just onboarded onto a repo and has to keep using AI for work, doesn't understand what's going on.

Check it out: https://www.youtube.com/watch?v=sLdHGnW6-7c

Solution Summary

Intuition is an IDE that indexes your codebase into a living course which updates as you code. It provides you with a side-window (or siderail), that actively tells you what the file and code does, as well as its place in the repo and various code flows. It also provides you with a custom course based on what your codebase is built on (language, frameworks), architecture, as well as your actual code, and even provides quizzes to test your understanding. It also lets you catch up with whatever AI has pushed (What's new section).

Inspiration

About 2 years ago, when Cursor was first popularised, my friends were afraid to use it for work. We were all afraid we wouldn't learn anything. Fast forward 2 years, we all work in different big tech companies, and Cursor or AI-assisted tools is a must-use.

The same problem remained. You don't learn much when using AI tools

Our solution -- Intuition. An IDE built solely on that fear of skill atrophy, and built for humans to learn as fast as AI builds.

What it does

Intuition is an IDE that turns any repository into a living, personalized course:

Atlas maps your repo into systems and renders it as a knowledge map, each area shaded by how well you already know it.
The toggle-able ambient siderail follows the file you're in — naming its role, showing itt, what it imports), and letting you trace real end-to-end flows through thecode.
Learn generates a tiered curriculum taught against your actual files, with different difficulty levels calibrated to your learning levels (vibing → maintainer → built it).
What's Changed makes the IDE commit-aware: when a teammate or an AI agent pushes a commit, a badge lights up and Intuition writes a plain-English story of what changed, then walks you through the diff added in green, removed in red.

We demo it through two people:

How we built it

Forked VS Code and did a massive frontend overhaul, improving ergonomic spacing and adding tutorials and a modern look to make it more appealing to younger users.
- Added a self-contained learning layer as a workbench contribution — the ambient rail lives in the auxiliary bar, Atlas in its own window.
A native, knowledge graph indexer engine reads the packages, files, and import/call edges. This process is done with ZERO LLM, so structure is fast and deterministic. The graph is partitioned into right-sized, directory-aligned "systems."
Knowledge graph is able to utilise a custom-written algorithm to detect files involved in changes, making minmal changes to indexed graph on commits.
A provider seam separates the frontend from the intelligence: all prose (-report stories, hover notes) comes from a model provider: ChatGPT bydefault, with bring-your-own-key and IDE language models supported and is cached with source-hash invalidation, so explanations only re-generate when the code actually changes.
Commit awareness reads git, diffs against a per-branch "reviewed" watermailes to render native green/red diffs in the editor.
Wrapped it in a first-run experience that spotlights the real workbench with coachmarks, a full brand system, and a packaged .exe with a baked key so it works with zero setup.

Challenges we ran into

VS Code is an extremely complex on long-running open source project. It is extremely complex to even understand and make changes to.
Async data in a reactive UI. A startup load-order race let the rail render before the indexed systems resolved, leaving it stuck on an empty state a classic "works on relaunch" bug that we had to fix at the right event, not guess at.
Making AI feel instant. Raw model latency is too slow to read, so we render structure immediately and stream prose in second, caching everything grounded in real source.

Accomplishments that we're proud of

It's a real IDE, not a prototype. It runs on real repositories, indexes them deterministically, and renders the map, the curriculum, and the change reports against the actual code.
The learning layer is fully decoupled behind a provider seam, so the intelligence can grow as its own backend.
Commit-aware review that writes a readable story of an AI's change and stlt for the agent era.
A cohesive product end to end: tutorial for new users, multiple features covering different workflows.

What we learned

The average IDE is way too complicated for new users.
VSCode doesn't have a tutorial at all, which is ridiculous considering there's like 100 buttons on the main page.