Anchor

When the waves rise, keep learning on solid ground.

Inspiration

We grew up as the first generation that never had to sit alone with a blank editor and a broken program. Autocomplete finishes our functions. Chat windows fix our bugs before we've even understood them. It's an incredible convenience — and it's quietly changing what it means to learn to code.

Talk to any of us honestly and you'll hear the same confession: we can ship things, but we freeze the moment the AI isn't there. A whiteboard interview. A competitive programming round. A production outage at 2 a.m. with no assistant in sight. The muscle that used to get built by struggling — tracing through your own logic, sitting with a failing test until it clicks — never quite forms when the answer is one keystroke away.

We didn't want to build another tool that writes code for you. We wanted something closer to what learning used to feel like: a patient person sitting next to you, watching you work, nudging you only when you're actually stuck, and asking you to explain your thinking instead of doing the thinking for you. That's Anchor. Not a co-pilot that takes the wheel — a mentor that keeps a hand near the tiller and lets you steer.

What it does

Anchor is a single authenticated workspace built around four connected experiences:

Coding Mentor — write code, run static analysis (Ruff/ESLint), execute it for real, and get plain-language explanations of why something failed instead of just being handed the fix. Progressive hints unlock one level at a time, so help scales with how stuck you actually are, not how stuck you say you are.
Rocky, the live tutor — the part that makes Anchor feel different. Rocky watches quietly while you work and only speaks up after a real pause, the way a teacher glances over your shoulder rather than hovering. You can chat with Rocky, ask for a hint, or wave him off — he adapts either way.
Execution Lab — a step-by-step trace visualizer. Instead of just seeing stdout, you can rewind your own program, inspect variables at each line, watch the call stack grow and shrink, and actually see the mental model you're supposed to be building.
Interview Engine — turns whatever you just solved into a live technical interview: follow-up questions, a request to justify your approach out loud, and a final report with a score and what to practice next — the exact skill that gets rusty when an assistant always speaks for you.
Analytics — a running record of what you've solved, how your scores trend, and which problems are recommended next based on where you're actually struggling.

Under the hood, the learner's ongoing profile — mentor tone, hint depth, problem difficulty, how often Rocky checks in — is continuously nudged toward the zone where practice is hardest without being demoralizing, something like a moving weighted average:

$$ p_{t+1} = p_t + \alpha \left( s_t - p_t \right) $$

where $p_t$ is the learner's current estimated skill/comfort level, $s_t$ is the signal from the latest session (score, stuck-time, hint usage), and $\alpha$ is a learning rate that keeps the system responsive without overreacting to one bad session — the same instinct a good human tutor has.

How we built it

The backend is a FastAPI service: JWT auth, project/session workspaces, Piston for sandboxed code execution, Ruff/ESLint for static analysis, and an LLM (via Groq) driving the mentor conversations, hint generation, and the interview coach. PostgreSQL holds accounts, sessions, executions, hints, and learner profiles; Redis backs Rocky's live-tutor state so nudges stay responsive. The Execution Lab and Interview Engine are their own bundled module, stitched into the same workspace so a learner never has to leave the flow of "write → run → get stuck → get help → understand → move on."

The frontend is one merged workspace — a persistent sidebar ties Coding Mentor, Execution Lab, Interview Engine, and Analytics together so context (your current code, your last run, your problem) flows between them instead of resetting every time you switch tabs.

Challenges we ran into

Getting Rocky to feel like a tutor and not a nag was harder than any of the backend plumbing. Too eager, and he interrupts flow state — the exact thing that kills real learning. Too passive, and he's indistinguishable from having no help at all. We spent real time tuning when a "pause" actually means someone is stuck versus just thinking, and making sure a hint request always costs the learner something (an admission that they want help) rather than being auto-served.

The other genuine challenge was infrastructure, ironically: giving a learner real, sandboxed code execution without giving anyone a way to escape that sandbox. Wiring together Postgres, Redis, and an isolated execution engine so that "Run code" is instant and safe — while keeping the whole thing deployable on a shoestring hackathon timeline — took more late-night debugging than the AI parts did.

What we learned

The most useful thing an AI tutor can do isn't answer the question — it's withhold the answer at exactly the right moment. Building Anchor made us think seriously about the difference between assistance and dependency, and about designing hint systems, pacing, and feedback that protect the struggle a learner actually needs, instead of engineering it away.

What's next

Deeper personalization (the recommender currently ships with a synthetic bi-encoder we're excited to retrain on real usage), more languages in the Execution Lab, and giving Rocky memory across sessions — so the mentor you talk to in month two actually remembers the habits you were working on in week one.