SkillDuel — I Built an AI Socratic Learning Partner for My Friend (Runs 100% Locally, Free Forever)

dineshkottaKota — Mon, 05 Oct 2026 07:08:22 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

⚡ SkillDuel — an adaptive AI Socratic learning partner that challenges you with smart, probing questions to make you actually think instead of just passively consuming content.

I built this for my friend who has been learning Python for 3 months. She felt stuck — she could follow tutorials, but wasn't sure if she truly understood things or just recognized familiar patterns. She needed something that would ask her the hard questions, kindly and adaptively, without judgment.

SkillDuel works for any skill — Python, chess, cooking, math, a new language. You type your answers and the AI:

Evaluates your understanding with honest, warm feedback
Explains the ideal answer clearly
Drops a deeper insight to spark curiosity
Adapts — harder if you nail it, gentler if you're struggling
Tracks XP and streaks to keep you motivated

When I showed it to her, she said: "This is the first time I've actually had to think instead of just type."

Demo

🖥️ Run locally in 3 steps (see How I Built It below). No deployment needed — that's the point.

1. Enter your name + skill → choose difficulty → pick your local model
2. AI asks a Socratic question ("What happens when Python evaluates `2 + True`?")
3. You answer → AI evaluates, explains, and gives a deeper insight
4. XP + streaks update → next adaptive question loads

Code

SkillDuel/
├── backend/
│   ├── main.py           ← FastAPI + LangChain Socratic engine (~300 lines)
│   └── requirements.txt
├── frontend/
│   └── index.html        ← Full dark-mode UI, single file, no framework
└── README.md

Backend — the Socratic engine core (backend/main.py):

# LangChain orchestrates two prompts per round:
# 1. Generate a Socratic question adapted to current level + topic
# 2. Evaluate the answer and generate the next question

SYSTEM_PROMPT = """You are SkillDuel — a brilliant, warm Socratic learning partner.
Your friend {friend_name} is learning {skill} at the {level} level.
Ask ONE focused question. Use the Socratic method.
Respond ONLY with JSON: { "question": "...", "hint": "...", "topic": "..." }"""

EVALUATE_PROMPT = """Evaluate {friend_name}'s answer while they learn {skill}.
Question: {question} | Answer: {answer}
Respond ONLY with JSON: { "is_correct": true, "score": 0-100,
  "feedback": "...", "explanation": "...", "follow_up_insight": "..." }"""

The app calls Ollama's local HTTP API directly (localhost:11434) — no cloud, no keys.

Adaptive difficulty logic:

if score >= 80:
    xp_gained = 30
    session["streak"] += 1
elif score >= 50:
    xp_gained = 15
    session["streak"] = max(0, session["streak"] - 1)
else:
    xp_gained = 5
    session["streak"] = 0

# Streak bonus — 3+ correct in a row = 1.5x XP
if session["streak"] >= 3:
    xp_gained = int(xp_gained * 1.5)

How I Built It

Open-source stack — every piece:

Layer	Technology	Why
🦙 LLM Runtime	Ollama	Runs any open-weight model locally
🔗 Agent Framework	LangChain Core	Prompt orchestration + output parsing
⚡ API	FastAPI	Async Python backend
🎨 UI	Vanilla HTML/CSS/JS	Zero dependencies, single file
🧠 Models	llama3.2 (default)	Swap to Mistral, Gemma, Phi, CodeLlama freely

Architecture:

Browser (index.html)
    ↓ REST (localhost:8000)
FastAPI + LangChain
    ↓ HTTP (localhost:11434)
Ollama → llama3.2 (local, on your machine)

To run it yourself:

# 1. Install & start Ollama
winget install Ollama.Ollama
ollama pull llama3.2

# 2. Start the backend
cd backend && pip install -r requirements.txt && python main.py

# 3. Open frontend/index.html in your browser

LangChain handles the two-prompt pipeline — one to generate an adaptive Socratic question, one to evaluate and explain the answer — with robust JSON parsing to handle LLM output variability.

Why Does Open Innovation Matter?

Four things that would be impossible with a closed API:

🔒 True privacy. My friend's learning journey — her struggles, her gaps, her questions — stays on her machine. No logs shipped to a server she doesn't control. A closed API makes that impossible by definition.

💸 $0 to run. There's no API bill. No credit card. No rate limits. A student or someone in a lower-income country can run this forever at the cost of electricity. Closed APIs price people out.

🔄 Model freedom. Learning to code? Use codellama. Want faster responses on a slow laptop? Switch to phi3. Want the most capable model? Run llama3.1:70b if you have the GPU. You control the intelligence, not a vendor.

✏️ Full hackability. The Socratic prompts are plain text in main.py. My friend can edit them — make the AI stricter, warmer, more technical, more playful. She can fine-tune a model on her own Q&A style. A closed API gives you a black box; open source gives you a whiteboard.

Open innovation here means: the tool belongs to the person using it.

Prize Categories

🦙 Ollama — core inference runtime, runs all local models
🔗 LangChain — open-source agent framework powering the Socratic engine

Built in one weekend. Works on a laptop with no internet. Costs nothing to run. The data stays yours.