Frequently Asked Questions

CodeEvaluator is an AI-powered platform for training code reading and technical writing skills. You read a real code snippet (currently Java, C, Python, JavaScript, or SQL — the list is growing), write an explanation in your own words, and receive an AI score across four core axes: Accuracy, Completeness, Clarity, and Insight — each from 0 to 100. But that is not all: each snippet carries topic tags (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections), and every tag has its own scoring rubric — making the evaluation multi-dimensional, not just four numbers. After 20+ attempts the platform generates a personal AI analysis of 11 modules: level, strengths and weaknesses, error patterns, time dynamics, recommendations. Patterns are tracked through the Pattern Ledger — a registry that accumulates recurring errors and wins across all analysis sessions.

CodeEvaluator is for anyone who wants to get better at reading and understanding code. A student just starting out will train breaking down unfamiliar constructs. A junior developer will prepare for code review and technical interviews. A mid-level or senior developer will sharpen the ability to read legacy code quickly and explain decisions precisely to colleagues. People switching careers will learn to speak the language of developers. The common thread: the platform is for those who care not just about writing code, but understanding and explaining it — to themselves, their team, a reviewer, or an interviewer.

LeetCode and Codewars test your ability to write code — you solve an algorithmic problem, pass tests, and meet complexity requirements. CodeEvaluator tests the opposite: your ability to read and explain already-written code. According to SonarSource, developers spend less than 32% of their working week actually writing code. Robert C. Martin in Clean Code describes the reading-to-writing ratio as 10:1. Research on program comprehension (GOTO Conferences, Felienne Hermans) shows that up to 60% of time goes into understanding existing code. Yet almost no training platform targets this skill. CodeEvaluator also trains technical writing — the ability to describe code precisely in human language. That skill is needed in code review, onboarding, documentation, and team communication. LeetCode does not teach this.

No. Registration does not require any payment details. The platform is currently in beta.

Currently five languages are available in beta: Java, C, Python, JavaScript, and SQL. Each has snippets at three difficulty levels — Easy, Medium, and Hard. On the practice page you can filter by language, difficulty, and tag to focus on exactly what you want to improve. The platform is in active development — the language list will grow.

Code comprehension is the ability to read unfamiliar code and understand what it does, how it works, why it is written that way, and what its constraints and edge cases are. It is a fundamental developer skill used constantly: during onboarding into a new project, in code review, when debugging, when working with legacy code, and in technical interviews. Most learning platforms teach writing code — CodeEvaluator closes the gap by directly training comprehension through every practice session.

Yes — AI is the core of the platform, working on two levels. First: after every attempt, AI scores your explanation across four axes (Accuracy, Completeness, Clarity, Insight — each 0 to 100). Every tag (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections) has its own rubric, so the evaluation is multi-dimensional. Second: after 20+ attempts the platform generates a personal AI analysis of 11 modules — overall level, strengths, weaknesses, language breakdown, difficulty breakdown, tag analysis, time dynamics, error patterns, Pattern Ledger Scoreboard, recommendations with an action plan, and recommended snippets matched to your weak spots.

Both modes score the same four axes — Accuracy, Completeness, Clarity, Insight — but the requirements and formulas are fundamentally different. In Normal, covering the core logic is enough; deep-analysis points like complexity and edge cases are a bonus. In Hardcore they are mandatory: you must provide O() notation for time and space, formal algorithm and pattern names, concrete edge cases with specific input values, and pre- and post-conditions. 'Linear complexity' without O(n) in Hardcore scores zero for that element. The Insight axis in Normal has 5 elements at step 20; in Hardcore it has 10 elements at step 10. Completeness in Hardcore counts all points including deep analysis. After a result in Hardcore, Focus Points are shown — key aspects of that specific snippet the AI pays special attention to. XP in Hardcore is higher: Easy ×1.5, Medium ×2.5, Hard ×4.0 vs ×1.0 / ×1.5 / ×2.5 in Normal. Each mode has a separate XP pool and separate analytics.

There is no native iOS or Android app yet. The site is responsive and works on mobile devices — you can read snippets and write explanations on a phone or tablet. If a mobile app matters to you, let us know.

Yes — access to practice requires an account. Two options: email and password, or sign in with Google. Registration takes less than a minute and requires no payment details. An account is needed to save your attempt history, accumulate XP, build analytics, and unlock achievements.

Most developer work is not writing new code — it is reading existing code. You read to understand a bug, onboard into a new project, review a colleague's pull request, extend legacy functionality, or prepare for a technical interview. Research on program comprehension (Felienne Hermans, 'The Programmer's Brain', 2021) shows that up to 60% of development time goes into reading and understanding code. A developer who cannot read code fluently is slower at every downstream task: debugging, reviewing, architecture decisions, and communication. Training this skill directly accelerates everything else.

Improvement is measurable within 2–4 weeks of consistent daily practice. The platform's analytics dashboard tracks your scores over time across all four axes — Accuracy, Completeness, Clarity, Insight — as well as per-tag metrics (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections). Most users see a clear upward trend in their weakest axis within 20 attempts. Sustained practice over 1–3 months produces durable improvement. The key variable is not time spent but the quality of feedback: random reading without feedback plateaus quickly, while scored explanations with AI analysis compound.

The most effective method combines three elements: deliberate exposure to unfamiliar code, active output (explaining what you read), and immediate feedback. Passive reading does not train comprehension — you must articulate your understanding in words. This is the core mechanism of CodeEvaluator: you read a real snippet, write a full explanation, and receive AI scores across four axes plus tag-level rubrics. The act of writing forces you to surface gaps in your understanding that silent reading hides. Adding difficulty filters and mode selection (Normal vs Hardcore) ensures you always train just beyond your current level.

Far more than most developers expect. Robert C. Martin's 'Clean Code' (2008) describes the reading-to-writing ratio in production codebases as roughly 10:1 — for every line written, ten are read. A SonarSource study found developers spend less than 32% of their working week writing new code; the majority goes to reading, reviewing, and understanding existing code. Felienne Hermans' research on program comprehension confirms that reading is the dominant activity in software development. Despite this, almost no mainstream training platform targets reading as a primary skill — most focus exclusively on writing.

Several factors compound: absent or misleading variable names, no documentation or outdated comments, implicit domain knowledge baked into logic without explanation, accumulated workarounds for old bugs, and architectural patterns that made sense in a different context. Cognitive load research shows that when working memory is overloaded — too many unknowns at once — comprehension breaks down. The antidote is systematic decomposition: identify what you know, isolate what you don't, trace data flow in small steps. CodeEvaluator's Hard snippets deliberately include dense, realistic code to train exactly this kind of structured breakdown under pressure.

Experienced developers use a layered approach: start with the outermost structure (what does this module/function/class expose?), then trace the main execution path before diving into branches. Identify the data model early — understanding what data flows through a system explains most of its logic. Use naming as a first signal: a function named 'calculateTax' tells you intent before you read a line. Resist reading every detail on the first pass; scan for structure, then zoom in on the parts that matter for your current question. This skill is exactly what CodeEvaluator trains — your explanation demonstrates whether you extracted the right signals.

Speed comes from pattern recognition, not scanning faster. When you have seen 50 implementations of binary search, you recognize the next one in seconds — your brain matches the pattern rather than parsing each line fresh. Building this library of patterns requires deliberate exposure across languages, difficulty levels, and topic tags. CodeEvaluator structures this exposure: you read snippets tagged by topic (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections — the list is growing), so your pattern library develops systematically. Explaining what you read in writing further reinforces each pattern, converting short-term recognition into durable memory.

Code reading is comprehension — understanding what code does and how. Code review is evaluation — judging whether code is correct, maintainable, secure, and consistent with team standards. You cannot do a good code review without first doing good code reading; comprehension is a prerequisite for evaluation. CodeEvaluator trains the comprehension layer: can you accurately describe what this code does, at what level of completeness, with what clarity, and with what depth of insight? Those same skills transfer directly to review quality. Developers who train comprehension first write faster, more precise review comments.

The most reliable path is exposure plus articulation. Exposure alone — reading lots of code passively — builds familiarity but not fluency. Articulation — explaining what you read in your own words — forces your understanding to become precise. When you cannot explain something clearly, you do not understand it yet. CodeEvaluator structures this loop: read a real snippet, write an explanation, receive AI feedback on what was accurate, complete, clear, and insightful. The feedback identifies specific gaps — an Accuracy score drop for misreading a condition, a Completeness miss for skipping a side effect — and the dashboard shows patterns across attempts.

Felienne Hermans identifies several in 'The Programmer's Brain' (2021): working memory (holding multiple values and states simultaneously), chunking (recognizing larger patterns from smaller units), tracing (following execution flow mentally), filtering (ignoring irrelevant detail), and mental model construction (building a representation of system state). Each can be trained. CodeEvaluator's four axes map to some of these directly: Accuracy tests whether your mental model is correct, Completeness tests whether you filtered too aggressively, Insight tests whether you chunked at the right level of abstraction.

Writing a coherent explanation forces you to resolve every ambiguity. When you read silently, your brain fills gaps with plausible interpretations and moves on — you feel like you understood, but the gaps remain. When you write an explanation, every sentence requires a definite claim: the loop terminates when X, the function returns Y in case Z. If you cannot make that claim, the gap becomes visible. This is the mechanism behind the Feynman Technique and why tutoring others accelerates your own learning. CodeEvaluator operationalizes it: every attempt requires a written explanation, and AI feedback identifies exactly which claims were wrong, missing, or imprecise.

Richard Feynman's learning method: explain a concept in simple language as if teaching someone with no background. If you cannot explain it simply, you do not understand it yet — go back and close the gap. Applied to code: read a snippet, close it, and write an explanation as if explaining to a colleague unfamiliar with the language. Every vague phrase ('it does some processing') marks a gap. CodeEvaluator formalizes this: your explanation is scored on Accuracy (did you describe it correctly?), Completeness (did you cover all significant behavior?), Clarity (is your explanation coherent?), and Insight (did you surface deeper patterns?). The AI functions as the impartial judge Feynman's method requires.

Speed and accuracy are not in tension once pattern recognition is established — they move together. The mistake is trying to read faster before the underlying patterns are solid. Build accuracy first: practice explaining snippets completely and correctly. As patterns solidify, recognition becomes automatic and speed follows. CodeEvaluator's difficulty progression supports this: start with Easy snippets to build accurate recognition of common patterns, then move to Medium and Hard where the same patterns appear in denser, more ambiguous contexts. The Insight axis specifically rewards recognizing higher-level patterns — algorithm class, complexity, design patterns — which is the cognitive layer that enables true reading speed.

The most frequent: reading line-by-line instead of structurally (missing the forest for the trees), over-indexing on variable names while ignoring control flow, assuming you understood after one pass without verifying, skipping error handling and edge cases as 'not the main logic', and confusing what code does with what it is supposed to do. CodeEvaluator's scoring penalizes these patterns specifically: a Completeness miss for skipping error handling, an Accuracy drop for misreading control flow, an Insight miss for not recognizing the algorithm class. The dashboard aggregates these patterns across attempts — the Pattern Ledger tracks recurring errors so you can see systematic weaknesses, not just individual mistakes.

Senior developers use entry points strategically. Rather than reading files top-to-bottom, they find the request entry point (main, router, controller), trace one representative flow end-to-end, and build a structural map before reading any module in detail. They look for invariants — contracts, assertions, error boundaries — before reading implementation. They read tests before production code when available, since tests document intended behavior more reliably than comments. They identify the data model early because data structure explains logic. These are skills, not intuitions — they can be trained. CodeEvaluator's Hardcore mode demands this kind of structural thinking: Focus Points shown after each result highlight what the AI was specifically looking for.

AI code review is automated analysis of code or code-related text using large language models. It covers two distinct applications: reviewing source code for bugs, style, and correctness (what tools like GitHub Copilot or CodeRabbit do), and reviewing developer explanations of code for accuracy, completeness, and clarity (what CodeEvaluator does). CodeEvaluator focuses on the second: after you write an explanation of a snippet, AI evaluates your explanation across four axes — Accuracy, Completeness, Clarity, Insight — each scored 0–100. Every tag on the snippet (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections) also has its own rubric, making the review multi-dimensional.

When you submit an explanation, it goes to the AI model together with the original snippet, the snippet's topic tags, the active mode (Normal or Hardcore), and a structured prompt containing scoring rubrics for each axis and each tag present on the snippet. The AI evaluates your explanation against all rubrics simultaneously and returns a numeric score per axis, tag scores where applicable, and a list of missed points. The backend records the attempt, updates your XP, and — after 20 or more attempts — makes your personal AI analysis available. The analysis runs as a separate pipeline across all your attempts, not just the last one.

Human code review brings contextual judgment, domain knowledge about your specific codebase, knowledge of team conventions, and social nuance. AI code review brings consistency, speed, and availability at scale. A human reviewer might overlook a logical error because they trust a colleague's track record; AI applies the same rubric every time. A human reviewer adapts to unspoken team context; AI cannot. For training purposes, AI review has a key advantage: it is available instantly on demand, gives structured numeric feedback across multiple dimensions simultaneously, and tracks patterns across hundreds of attempts — something no human reviewer could do continuously.

Not fully — and CodeEvaluator is not trying to replace them. Human reviewers bring system-level context, design judgment, security intuition, and organizational knowledge that AI cannot replicate reliably. Where AI adds genuine value is in the first pass: catching missed behaviors, incomplete descriptions, and surface-level clarity issues before a human reviews. It also functions as a training tool — enabling thousands of scored practice attempts at zero marginal cost, which no human review process can provide. Think of it as a training partner, not a replacement. The goal is developers who bring stronger comprehension and communication skills to human-reviewed work.

The AI analysis is a personal performance report generated after 20 or more attempts. It runs across your full attempt history and produces 11 modules: overall level assessment, strengths, weaknesses, error patterns, language breakdown, difficulty breakdown, tag analysis (per-tag score trends for all currently tracked tags), time dynamics (how your scores change over sessions), Pattern Ledger Scoreboard (a registry of recurring errors and wins across analysis sessions), concrete recommendations with an action plan, and a set of recommended snippets matched to your specific weak spots. The analysis is regenerated each time you request it, incorporating all attempts up to that point.

The AI scoring is designed to be consistent and calibrated against rubrics, not perfectly deterministic in the mathematical sense. AI models can make mistakes — an explanation that deserves 80 on Accuracy might occasionally score 75 or 83 on a re-run. We do not guarantee identical scores for identical inputs, but in practice the variance is small, typically within 10 points. What we do guarantee is that the scoring criteria are fixed and published (the same rubrics apply to every attempt in the same mode), and that large improvements in your explanation quality will always produce measurably higher scores. Use the scores as a reliable directional signal, not a precise measurement.

The score measures the quality of your written explanation of a code snippet — not your ability to write code. Specifically: how accurately you described what the code does (Accuracy), how completely you covered all significant behavior including edge cases and side effects (Completeness), how clearly and coherently your explanation reads (Clarity), and how much deeper analytical value you extracted — algorithm class, complexity, design patterns, potential issues (Insight). Every tag on the snippet (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections) also contributes its own rubric score. The combined result is a multi-dimensional profile of your current comprehension and communication ability.

Each attempt is evaluated by a language model using a structured prompt. The prompt contains: the original code snippet, your explanation, the active mode (Normal or Hardcore), rubric definitions for all four axes, and tag-specific rubric extensions for each tag present on the snippet. The model is instructed to score each axis on a 0–100 scale and return scores as structured data. The backend validates the response, persists the attempt with all scores, updates XP based on mode and difficulty multipliers, and queues any analytics updates. The full rubric details for each scoring axis and each tag are defined in the backend codebase.

Accuracy measures whether your description of the code is factually correct. It penalizes misidentified logic (describing a loop as iteration when it is recursion), wrong return value claims, incorrect state descriptions, and confusing what the code does with what you assumed it does. A high Accuracy score means your explanation would not mislead a reader who has not seen the original snippet. In Hardcore mode, Accuracy rubric requirements are stricter — formal algorithm names and complexity notation are expected, and absence of these is penalized rather than treated as optional bonus material.

Completeness measures how thoroughly you covered the significant behavior of the snippet. It is not about word count — a short explanation can score high if it captures all meaningful behavior. It penalizes omissions: skipped error handling, unmentioned return value variants, missed side effects, ignored input constraints, and uncovered edge cases. In Normal mode, deep analysis points like complexity and edge cases are bonuses. In Hardcore mode they are required: missing them drops your Completeness score, not just the Insight score. The intent is that a reader of your explanation could implement equivalent behavior without seeing the original code.

Clarity measures how readable and coherent your explanation is as written communication. It assesses logical flow, precision of language, absence of ambiguity, and whether technical terms are used correctly. A high Clarity score means your explanation is unambiguous and can be understood by a developer unfamiliar with the specific snippet. Common Clarity failures: using vague terms ('it processes the data'), circular descriptions ('it does what it says'), unexplained jargon, and sentence structures that obscure the logic they are trying to describe. Clarity is distinct from Completeness — an explanation can be complete and still be unclear, or clear and still be incomplete.

Insight measures the depth and analytical value beyond literal description. In Normal mode it has 5 elements scored at 20 points each: identifying the algorithm or pattern class, noting time and/or space complexity, flagging potential issues or limitations, recognizing design choices and their trade-offs, and connecting the snippet to broader patterns. In Hardcore mode it has 10 elements at 10 points each — the same categories broken into finer-grained requirements, with formal O() notation required and edge cases needing specific input values rather than general descriptions. Insight is the axis that separates developers who understand code from developers who can explain it deeply.

There is no formal appeal mechanism — scores are generated automatically and not reviewed manually. If a score seems wrong, the most useful step is to re-read the rubric for the axis in question and compare your explanation against it specifically. In practice, apparent 'unfair' scores usually reveal a genuine gap: a Completeness miss that seemed minor but was actually significant to the rubric, or an Accuracy issue in a sentence that felt correct but was ambiguous. The AI can make mistakes, and variance within about 10 points is possible. If your score is consistently lower than expected on a specific axis across multiple attempts, the dashboard pattern will confirm whether it is a systematic gap worth addressing.

CodeEvaluator uses Google Gemini models via the Vertex AI platform. The specific model version may change as newer versions become available — we use the model that provides the best balance of scoring consistency and response quality at the time. We do not disclose which specific version is active at any given time. The evaluation prompt, rubrics, and scoring structure are our own design — the AI model is the engine, not the methodology.

Each snippet may have hints that help you understand what to focus on in your explanation. Requesting a hint reduces the XP you earn for that attempt — the penalty amount is set per snippet and per hint tier, so it varies. Hints are always optional; you can attempt any snippet without them. In Hardcore mode, after you submit and receive your score, Focus Points are shown — key aspects of the snippet the AI was specifically evaluating. Focus Points are revealed after submission, not before, so they cannot influence your attempt but help you understand the scoring criteria for future practice.

The Pattern Ledger is a registry that tracks recurring patterns across all your AI analysis sessions — both errors and strengths. Unlike per-attempt feedback which is one-time, the Pattern Ledger accumulates entries across analysis runs: if the AI identifies the same type of error (for example, consistently missing time complexity in Insight) across multiple sessions, the Ledger records it as a pattern rather than an isolated incident. The Ledger also tracks recurring strengths — patterns you consistently get right. This persistence transforms one-off feedback into longitudinal insight. The Pattern Ledger Scoreboard is one of the 11 modules in the full AI analysis report.

The snippet library is growing continuously. Currently (beta) the platform has snippets across five languages — Java, C, Python, JavaScript, and SQL — at three difficulty levels each: Easy, Medium, and Hard. Every snippet is tagged with one or more topic tags from the current set (Loops, Arrays, Strings, SQL, API, Regex, Async, Collections), so you can filter by the areas you want to train. Exact counts change as new snippets are added, so the number displayed on the practice page is always current.

New snippets are added regularly as the platform develops. The authoring process includes factual verification, difficulty calibration against rubric scoring anchors, and deduplication to ensure each snippet covers a distinct concept. The current library is in beta — volume will increase significantly over time. If you run through all available snippets in a language or difficulty, the practice page will reflect that, and the next batch will be added in subsequent updates.

Yes. On the practice setup page you can filter by language, difficulty (Easy, Medium, Hard), and topic tag. You can combine filters — for example, Hard Python snippets tagged with Async — to target exactly the area you want to train. The platform does not enforce a progression path; you can attempt Hard snippets from day one if you prefer the challenge. The dashboard analytics will then show your scores across the difficulty breakdown, making it easy to see where you are strongest and where to focus next.

The dashboard is a four-tab analytics center covering your practice history in detail. The Overview tab shows summary metrics and recent activity. The Metrics tab — the analytical core — breaks down your scores by language, difficulty, and tag, showing per-axis trends over time. The History tab lists all your attempts with scores and allows replaying any past explanation. The Achievements tab tracks unlocked milestones. After 20 or more attempts, the AI Analysis panel becomes available within the dashboard, showing your personal 11-module performance report generated from your full attempt history.

Achievements are milestones unlocked by reaching specific thresholds in your practice activity. They cover a range of dimensions: attempts completed, XP accumulated, languages practiced, streaks maintained, difficulty levels cleared, and score thresholds reached on specific axes. Achievements are visible in the dashboard Achievements tab. They serve as both progress markers and implicit guidance — the achievement structure reflects what balanced, well-rounded practice looks like across languages, difficulties, and modes.

Yes. The leaderboard ranks users by XP accumulated across their attempts. XP is awarded per attempt based on the mode and difficulty: Hardcore yields higher XP multipliers than Normal (Easy ×1.5, Medium ×2.5, Hard ×4.0 in Hardcore vs ×1.0, ×1.5, ×2.5 in Normal). Hints requested during an attempt reduce the XP awarded. The leaderboard reflects sustained effort across the platform, not just high scores on individual attempts. Normal and Hardcore have separate XP pools, and each mode tracks its own analytics independently.

Every snippet carries one or more topic tags (currently: Loops, Arrays, Strings, SQL, API, Regex, Async, Collections — the list is growing). Each tag has its own scoring rubric that extends the base four-axis evaluation. For example, a snippet tagged Regex will have rubric elements specific to regex pattern analysis — describing the pattern's structure, its matching behavior, edge cases specific to regex semantics. Your tag scores are tracked separately in the dashboard Metrics tab, giving you a per-tag performance profile. Tags function as additional scoring axes on top of the core four — Accuracy, Completeness, Clarity, Insight — making the evaluation multi-dimensional.

Yes. The practice setup page lets you filter by language before starting a session. You can select a single language — Java, C, Python, JavaScript, or SQL (currently in beta, more coming) — or any combination. Combine the language filter with difficulty and tag filters to build a focused practice session. For example, if you are preparing for a Java interview, filter by Java + Medium or Hard and work through the available snippets. Your analytics dashboard also breaks down scores by language, so you can see your comparative performance across all languages you have practiced.

The dashboard Metrics tab is built for this. It shows per-axis score trends across all your attempts, broken down by language, difficulty, and tag. You can see whether your Accuracy has improved over the last 30 attempts, whether your Insight scores are higher on Python than Java, and which tags consistently underperform. The time dynamics module in the AI analysis report adds another layer: it identifies whether your scores are trending up, plateauing, or declining, and flags specific patterns — for example, declining performance on Hard attempts after a period of only practicing Easy snippets. Taken together, the dashboard and analysis give you a complete longitudinal picture.

XP is awarded after every submitted attempt. The base amount depends on difficulty and mode. In Normal mode: Easy ×1.0, Medium ×1.5, Hard ×2.5. In Hardcore mode: Easy ×1.5, Medium ×2.5, Hard ×4.0. Hints requested before submission reduce the XP for that attempt — the reduction is set per hint and per snippet. Normal and Hardcore XP accumulate in separate pools, and each has its own leaderboard ranking. XP totals are visible on your profile and in the leaderboard. The system rewards consistent effort and willingness to attempt harder content, not just achieving high scores.

Go to the registration page and choose one of two options: create an account with email and password, or sign in with Google. Email registration requires a username, email address, and password — no payment details. Google sign-in completes registration in one click using your existing Google account. After registration you are taken directly to the platform. An account is required to save attempt history, accumulate XP, track analytics, and unlock achievements.

Your attempt history, scores, and analytics are private to your account — they are not visible to other users. The leaderboard displays usernames and XP totals only; no score breakdowns or attempt details are public. Your email address is not displayed anywhere on the platform. We do not sell user data. The platform is in beta, and the full privacy policy is available at the link in the footer.

CodeEvaluator works in all modern browsers: Chrome, Firefox, Safari, and Edge. The code display uses Monaco Editor (the same editor as VS Code), which requires a reasonably current browser version. Internet Explorer is not supported. If you experience display issues, updating to the latest version of your browser resolves most problems. The platform is also tested on mobile browsers — Chrome for Android and Safari for iOS — though the desktop experience is more comfortable for writing longer explanations.

Yes — the platform is responsive and functional on mobile. You can read snippets, write explanations, and submit attempts from a phone or tablet. The code display and text input adapt to smaller screens. That said, writing a detailed explanation in Normal mode — and especially in Hardcore mode, which requires O() notation, algorithm names, and specific edge cases — is more comfortable on a keyboard. There is no native iOS or Android app yet. If a dedicated mobile app matters to you, let us know.

Password reset is currently handled manually — the platform is in beta and the self-service reset flow is not yet available. If you need your password reset, contact support via the link in the footer and we will take care of it directly. If you registered with Google sign-in, password reset does not apply — use Google's own account management to control access.

The platform is currently in beta and community channels are being set up. If you want to be notified when a community space launches, or if you have feedback or questions in the meantime, use the contact link in the footer. We read every message.

Please report it using the contact link in the footer. Include what you were doing, what you expected to happen, and what actually happened. If the issue is with a specific snippet — for example, the code looks incorrect or the scoring seems off — include the snippet name or URL. Bug reports directly improve the platform and are genuinely appreciated. The platform is in active development and we address reported issues quickly.

Use the contact link in the footer of any page. There is no ticket system or phone support — the platform is in beta and support is handled directly. For general questions, feedback, and bug reports, the footer contact form is the right channel. Response times vary but we aim to reply within one business day. For urgent issues that block your access to the platform, include 'urgent' in your message subject.