Local-first · AI-native · Notebook-powered · Zero cloud required
Every developer knows this loop:
Tab 1: LeetCode problem
Tab 2: Stack Overflow (why is my recursion wrong?)
Tab 3: ChatGPT (explain this to me like I'm five)
Tab 4: YouTube tutorial
Tab 5: VS Code (where actual work happens)
You context-switch more than you code. And none of these tools talk to each other, remember what you struggle with, or care whether you actually understood the concept — or just copied the answer.
The industry gave you a practice platform. Then an AI assistant. Then an interview prep app. All separate. All disconnected from the place where you actually write code.
CogniForge Studio is the bet that this is all wrong.
Learning should happen inside the editor, with an AI that watches you code, adapts to where you're stuck, and guides you — not just generates for you. No tabs. No accounts. No cloud. Just you, your notebook, and an AI tutor that lives where your code lives.
CogniForge turns a VS Code notebook cell into a full learning environment:
┌─────────────────────────────────────────────────────────────┐
│ 📄 two-sum.pwtutor [CogniForge] │
├─────────────────────────────────────────────────────────────┤
│ │
│ ● Problem │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Given an array of integers nums and an integer │ │
│ │ target, return indices of the two numbers that │ │
│ │ add up to target. │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ● Your Solution [Python] │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ def two_sum(nums, target): │ │
│ │ for i in range(len(nums)): │ │
│ │ for j in range(i+1, len(nums)): │ │
│ │ if nums[i] + nums[j] == target: │ │
│ │ return [i, j] ← O(n²) 🤔 │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ● CogniForge [Optimize Mode] │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ ✦ Your solution is correct. Here's the tradeoff: │ │
│ │ │ │
│ │ Current: O(n²) time · O(1) space │ │
│ │ Optimal: O(n) time · O(n) space │ │
│ │ │ │
│ │ The key insight: what if you stored what you've │ │
│ │ already seen as you walk the array once? │ │
│ │ │ │
│ │ [▶ Reveal approach] [Try it first →] │ │
│ └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Ctrl+Shift+P → CogniForge: ___________
│
┌───────────────┼────────────────────────┐
│ │ │
💡 Hint 🔍 Explain 🐛 Debug
Socratic nudge. What your code Root-cause first.
No spoilers. actually does. Not just "here's
In plain English. the fix."
│
┌────────────────┴───────────────┐
│ │
⚡ Optimize 🎯 Interview Feedback
Complexity analysis Interviewer-style evaluation.
+ rewrite path. Correctness · Tradeoffs ·
Shows the why, Likely follow-ups.
not just the what.
You write code
│
▼
CogniForge analyzes ←──── codeAnalysis.js
· mistake type
· complexity signals
· hint ladder position
│
▼
Tutor responds ←──── promptEngine.js + LM API
· calibrated to YOUR profile
· aware of YOUR recent struggles
· paced to YOUR current track
│
▼
Local memory updates ←──── VS Code state, no server
· weak topics logged
· struggle streaks tracked
· next problem recommended
│
▼
You improve
(actually)
Most "AI learning tools" send your code to a server. Your half-finished solutions, your wrong answers, your debugging sessions — uploaded, processed, stored.
CogniForge doesn't.
┌─────────────────────────────────────────────────────────┐
│ YOUR MACHINE │
│ │
│ ┌──────────────┐ ┌──────────────────────────┐ │
│ │ Your Code │────▶│ CogniForge Engine │ │
│ └──────────────┘ │ │ │
│ │ · Code execution │ │
│ ┌──────────────┐ │ · Learner profile │ │
│ │ VS Code │────▶│ · Weak topic memory │ │
│ │ State │ │ · Struggle streaks │ │
│ └──────────────┘ │ · Problem catalog │ │
│ └──────────┬───────────────┘ │
│ │ │
│ ┌───────────────▼──────────────┐ │
│ │ VS Code LM API / Copilot │ │
│ │ Reasoning runs here, local │ │
│ └──────────────────────────────┘ │
│ │
└────────────────────────────┬────────────────────────────┘
│ Optional only
┌────────▼───────────┐
│ Sarvam API │
│ translation + │
│ voice output │
└────────────────────┘
What this means for you:
| Cloud-based AI tools | CogniForge Studio | |
|---|---|---|
| Your code leaves your machine | ✅ Always | ❌ Never (core features) |
| Works offline | ❌ | ✅ Full core functionality |
| Latency | Network round-trip | Instant (local LM) |
| Account required | ✅ | ❌ |
| Learner data on servers | ✅ | ❌ VS Code state only |
| Breaks without internet | Completely | Gracefully |
Your learning data is yours. Your code stays on your machine. Your progress doesn't live on someone else's server.
This matters especially if you're solving problems that touch proprietary code patterns, working in a low-connectivity environment, operating under strict data policies, or simply someone who doesn't want their wrong answers uploaded to a cloud.
CogniForge isn't another practice platform.
The thesis is this:
The next generation of developer learning won't happen on websites. It will happen inside the tools developers already use — with AI that watches, adapts, and guides in real time, without ever leaving the editor or phoning home.
Every design decision reflects this:
- Notebooks instead of isolated problem pages — because your editor is already your thinking environment
- Local state instead of accounts — because your learning profile should belong to you
- Tutor modes instead of code generation — because knowing why matters more than getting the answer
- Adaptive memory instead of streaks — because what you struggle with matters more than how often you show up
- Indian language support built in from day one — because 1.4 billion people shouldn't have to learn in their second language
Structured practice over a chosen topic, not random problem grinding.
Focus areas: DSA · Data Structures · Python · JavaScript · SQL · AI · GenAI
The difference from a LeetCode grind: CogniForge tracks which patterns you're weak on, not just which problems you've completed. It slows down when you keep hitting the same wall. It recommends the next problem based on where your actual gaps are.
CogniForge: Start Learning Mode · New Study Track Notebook · New Pattern Practice Notebook
Not generic coding rounds. Role-specific preparation with interviewer-calibrated feedback.
Supported roles:
Software Engineering AI / ML GenAI
Data Engineering Cloud / DevOps / SRE Cybersecurity
You get a role brief, representative problems, and feedback structured around the three things interviewers actually evaluate: correctness, tradeoffs, and clarity under follow-up.
CogniForge: Start Interview Mode · CogniForge: Interview Feedback
Bring any function. Any bug. Any confusing output.
CogniForge tells you what's happening and why — not just rewriting it for you. The goal is that you leave understanding the code better than when you came in.
Explain My Code · Give Me a Hint · Debug My Code · Optimize My Approach
- VS Code
^1.98.0 - Python 3 — for Python notebook cells
- Node.js — for JavaScript notebook cells
- GitHub Copilot + Copilot Chat — powers the reasoning layer (strongly recommended)
# Clone
git clone https://github.com/your-org/CogniForge.git
cd CogniForge
# Install
npm install
# Open in VS Code and press F5 to launch the Extension Host
code .1. Ctrl+Shift+P → CogniForge: Configure Learner Profile
2. Pick your track and difficulty
3. Ctrl+Shift+P → CogniForge: Start Learning Mode
4. Write code in the notebook cell · run it locally
5. Ctrl+Shift+P → CogniForge: Give Me a Hint
or: Explain My Code
or: Debug My Code
or: Optimize My Approach
6. Repeat until it actually clicks
Optional: Set a Sarvam API key (CogniForge: Set Sarvam API Key) to enable translated explanations and voice output in Indian languages.
| Category | Command |
|---|---|
| Notebooks | Start Learning Mode · New Practice Notebook · New Study Track Notebook · New Pattern Practice Notebook · Start Code Help Mode · Start Interview Mode · Import LeetCode Problem |
| Tutor | Explain My Code · Give Me a Hint · Debug My Code · Optimize My Approach · Interview Feedback · Speak Last Explanation |
| Config | Configure Learner Profile · Set Sarvam API Key |
| Setting | What it controls |
|---|---|
cogniforge.defaultRuntime |
Default code execution runtime |
cogniforge.pythonCommand |
Python executable path |
cogniforge.nodeCommand |
Node executable path |
cogniforge.reasoningModelVendor |
LM vendor for AI reasoning |
cogniforge.reasoningModelFamily |
LM family for AI reasoning |
cogniforge.sarvamModel |
Sarvam model selection |
cogniforge.translationScriptMode |
Native script vs. romanized output |
cogniforge.sarvamVoice |
Voice selection for TTS |
CogniForge/
├── src/
│ ├── extension.js # Entry point · notebook orchestration · command registration · memory updates
│ ├── promptEngine.js # Prompt construction for all tutor modes and adaptive reasoning context
│ ├── llmClient.js # VS Code Language Model API integration and Copilot availability checks
│ ├── sarvamClient.js # Translation and text-to-speech via Sarvam
│ ├── codeAnalysis.js # Mistake-type detection · complexity signals · hint ladder positioning
│ ├── problemCatalog.js # Curated learning tracks · interview role presets · notebook metadata
│ └── leetcodeClient.js # LeetCode import and notebook-ready problem shaping
├── examples/
│ └── two-sum.pwtutor # Example notebook in the extension's native format
└── package.json
- Local code execution depends on your installed Python / Node runtime
- AI guidance requires GitHub Copilot or a configured Sarvam API key
- LeetCode import depends on LeetCode's current public request shape
- SQL mode covers reasoning and explanation — embedded SQL runner not yet included
- No cross-device sync or cloud analytics (by design for core features)
- Stronger mastery tracking and weak-topic recovery paths
- Richer notebook UX — action-driven, collapsible hint reveal flows
- SQL execution via embedded local SQLite
- Expanded curated tracks and role packs
- Test coverage for notebook, prompt, and LM flows
- Demo GIFs and polished first-run onboarding
If you believe developer education belongs in the editor — help build it.
Priority areas:
- Notebook UX polish
- SQL mode implementation
- Stronger AI fallback behavior
- New curated learning tracks
- Test and mock LM coverage
- Multilingual experience improvements
See CONTRIBUTING.md to get started.
examples/two-sum.pwtutor
Open it in VS Code with the extension running to see the full notebook format in action.
MIT — build on it, learn from it, make it better.
The editor is the classroom. The notebook is the lesson plan. The AI is the tutor. Your data stays yours.
Built for developers who learn by doing — and want to actually understand what they did.