hermes

Start here 1

The general, start-from-zero entry for a need in this category: it works from a blank start, asks for what it needs and hands off to the specific entries. Example: Plan a trip.

Search and filter in Learning to code
  • Explain a piece of code

    Explains a piece of code step by step at the reader's level, starting with what it is for, then walking through how it works with a worked example and the parts that are easy to misread.

Specific 63

One situation, audience, tool or format inside the category. Example: Plan a road trip with children.

  • Explain a codebase

    Explains an unfamiliar codebase. Maps its structure, traces one real request end to end and names the concepts and gotchas a newcomer needs. Use when joining a project or reading an unknown repo.

  • Coding mentor

    Acts as a senior developer mentoring a junior, asking what they tried, explaining the why behind fixes and reviewing code to teach. Use for early-career developers who want to grow.

  • Explain a SQL query

    Explains a complex SQL query clause by clause in logical execution order, shows intermediate results on a tiny example, and points out bugs and performance traps. Use when inheriting a query.

  • Beginner coding buddy

    Acts as a patient coding helper for non-programmers, such as office workers, researchers and teachers, by explaining in plain words, keeping programs small and warning before anything risky.

  • Explain a concept with code

    Explains a programming concept through the problem it solves, a minimal runnable example, a common mistake and a quick self-check, pitched at the learner's level. Use to learn or teach a concept.

  • Create graded coding exercises

    Generates a graded set of coding exercises for one concept, each with starter code, automated tests, staged hints and a reference solution. Use for teaching, practice sessions or self-study.

  • Decode engineering jargon

    Explains the engineering terms in a message, ticket or meeting notes in plain words for a non-engineer, what each means for them, and the question to ask back. Use when a dev update is unclear.

  • Drill code reading

    Runs a code-reading game where the learner predicts what short snippets print or do, then gets the answer and the one concept they missed, with adaptive difficulty and a score.

  • Junior mentoring rules

    Standing rules for a coding assistant working in a junior developer's project so they stay the author, with proposals before edits, small explained diffs and no silenced checks.

  • Trace a program line by line

    Traces a short program line by line with a table of every variable's value after each step, so a beginner sees exactly how values change, where loops exit and why the output is what it is.

  • Tutor microcontroller basics

    Teaches a programmer new to hardware how microcontrollers work through small hands-on projects, one concept per session, with wiring checks and safety notes. Use when starting with embedded.

  • Plan a learning path for a technology

    Builds a week-by-week plan to get productive in a new language, framework or tool, built around hands-on milestones and skipping what the learner already knows. Use when picking up a new stack.

  • Draft a help request

    Coaches a stuck developer to turn a vague problem into a question others can answer, with goal, minimal reproduction, attempts, exact errors and versions. Use before asking for help.

  • Explain a project's dependencies

    Explains what each dependency in package.json, requirements, pyproject, go.mod, Cargo.toml or a Gemfile does in this project, and which are core, dev-only, overlapping or unused.

  • Explain a regular expression

    Explains a regular expression token by token, shows what it matches and misses on sample strings, and flags catastrophic backtracking, flavour differences and edge cases.

  • Pick a portfolio project

    Helps a junior or career-changing developer choose one portfolio project that proves what target jobs ask for, scoped to finish in weeks, with milestones. Use before starting a portfolio piece.

  • Review a beginner's code

    Reviews a learner's code with kind, teaching-first feedback on correctness and readability, limited to the few points that matter most, plus the next concept to learn. Use for new developers.

  • Guide me through my first coding project

    Guides a beginner through building a small real project milestone by milestone, where the learner writes the code, gets a hint ladder when stuck and a short review at each milestone.

  • Coach a test-driven coding kata

    Coaches a test-driven coding kata one requirement at a time, reviewing each failing test, minimal implementation and refactor before revealing the next step.

  • Explain an algorithm

    Explains an algorithm or data structure through intuition, a step-by-step trace on a small input, the invariant that makes it correct, complexity and runnable code in the learner's language.

  • Explain code review feedback you received

    Explains code review comments a developer received, covering what each reviewer means, the principle behind it, how to address it and how to reply, so the lesson carries to the next PR.

  • Explain the difference between two technologies

    Explains the real difference between two often-confused technologies or concepts, such as REST and GraphQL or processes and threads, with side-by-side code, misconceptions and when each fits.

  • Explain a project's test suite

    Explains a project's test suite for a newcomer, covering test types and layout, fixtures and mocks, how to run one test or a subset, and which areas are well or barely covered.

  • Review a learner's whole project

    Reviews a learner's small but complete project, covering structure, README, how it runs, tests, error handling and git history, and picks the three changes that would most improve it.

  • Run a network troubleshooting lab

    Simulates a small broken network where the learner runs ping, traceroute, dig and curl to find the fault, with consistent outputs and a debrief on troubleshooting method.

  • Tutor game math

    Teaches the maths game developers use, from vectors and dot products to interpolation, rotations and transforms, through gameplay problems with code in your engine. Use when game maths blocks you.

  • Explain a shell command

    Breaks down a shell one-liner or pipeline flag by flag and stage by stage, says exactly what it will read, change or delete, and warns before anything destructive or risky.

  • Explain a config file

    Explains a config file such as tsconfig, Vite, webpack, nginx, docker-compose or a CI YAML setting by setting, marking what differs from defaults, what is risky and what does nothing.

  • Explain a vulnerability class

    Teaches one vulnerability class, such as XSS, SQL injection, CSRF, SSRF, IDOR or path traversal, with a vulnerable snippet, how it is exploited, the fix and how to spot it in code review.

  • Practise GraphQL against a simulated endpoint

    Simulates a GraphQL endpoint with a printed schema, answering queries and mutations with data or spec-correct validation errors so learners practise fields, variables, fragments and pagination.

  • Practise in a simulated Linux shell

    Simulates a Linux terminal with a persistent fake filesystem, users and processes for safe command practice, with a hint mode that explains output and suggests the next command.

  • Explain infrastructure code

    Explains Terraform, Kubernetes or CloudFormation code as the resources it creates, how they connect, what drives cost, and which changes would replace or break something.

  • Practise HTTP against a simulated REST API

    Simulates a REST API that answers curl or raw HTTP requests with realistic status codes, headers and JSON, so learners practise methods, auth, pagination and error handling.

  • Teach me to debug my own bug

    Teaches a learner to debug their own real bug systematically, by asking for observations, a hypothesis and a test one step at a time instead of fixing it for them.

  • Teach me to write my first unit tests

    Teaches a beginner to write their first unit tests on their own code, covering what to test, arrange-act-assert, choosing edge cases, running the test runner and reading a failure.

  • Explain the patterns a codebase uses

    Identifies the design and architectural patterns a codebase already uses, where each appears and why it was likely chosen, so newcomers write code that fits instead of fighting it.

  • Quiz yourself on a codebase

    Quizzes a new team member on a real repository's structure, request flows, data model and conventions one question at a time, with every answer checked against the code and cited.

  • Explain a query plan

    Teaches you to read an EXPLAIN or EXPLAIN ANALYZE output node by node, what each operator does, how to read costs, rows and timings, and where the time actually goes.

  • Learn a new language from one you know

    Teaches a new programming language by mapping it onto one the learner already knows, covering idioms, false friends, tooling and graded exercises. Use when switching languages for a job or project.

  • Practise Docker in a simulated CLI

    Simulates the Docker CLI with images, containers, volumes and networks that persist across commands, teaching builds, port mapping, logs, debugging and cleanup without installing anything.

  • Practise git in a simulated repository

    Simulates a git repository with files, commits, branches and a remote, redrawing the commit graph after each command so learners practise branching, rebasing and recovery safely.

  • Practise MongoDB in a simulated shell

    Simulates a MongoDB shell with sample collections, returning documents and errors for queries, updates and aggregation pipelines and keeping data changes across turns.

  • Practise in a simulated PowerShell console

    Simulates a PowerShell console with real objects, pipelines, a fake Windows filesystem and services, teaching cmdlets and the object pipeline through hands-on practice.

  • Practise in a simulated Python REPL

    Simulates an interactive Python REPL that keeps variables across turns and prints results and tracebacks as Python would, with an optional plain-language explanation of each error.

  • Practise on a simulated SQL database

    Simulates a SQL database with a practice schema and seeded rows, returning result tables or the dialect's exact errors for each query and keeping changes across turns.

  • Explain a model training script

    Explains a PyTorch-style training script section by section, covering data loading, model, loss, optimiser, training loop and evaluation, with tensor shapes and the ML idea behind each part.

  • Explain a complex TypeScript type

    Explains a hard TypeScript type with generics, conditional, mapped, template literal or infer by evaluating it step by step on concrete inputs and naming the trick each part uses.

  • Practise regular expressions in a simulated tester

    Simulates a regex tester that marks matches and capture groups in sample strings, with a ladder of challenges that builds from literals up to lookarounds.

  • Train vim habits in a simulated buffer

    Simulates a vim buffer with a visible cursor, setting editing challenges and showing the buffer after each keystroke sequence so learners build motion and operator habits.

  • Explain how a library feature works inside

    Explains how a library or framework feature works under the hood, such as React hooks, an ORM's lazy loading or Express middleware, with a tiny reimplementation and the behaviour it explains.

Showing 50 of 63. See them all in search

Not: studying other subjects (education domain).