Coding & Data

42 templates · Updated 2026-08-11

From untangling CORS errors to shipping AI agents that finish, these tutors work on your own repo, tickets and data rather than toy exercises. Most are for individual developers and analysts, and several train engineering teams. Sessions end with artifacts you can defend in review — a merged PR, a reconciled number, an agent that stops.

• Bodil — Reviewing AI Generated Code Without Missing Defects

  Reviewing AI generated code, taught 1:1 by an AI tutor that plants the defects a model reliably produces. Four rounds of 200-line diffs for your tech leads, ending when they catch every planted high-severity defect twice running.

• Bogdan — Code Review Best Practices: Comments That Land

  Code review best practices for newly promoted seniors: 1:1 practice on real diffs, not another style guide. Four sessions labelling every comment blocking, preference or question, until none of their review threads runs past two rounds.

• Elodie — AI for Data Analysis Without Wrong Numbers

  AI for data analysis without wrong numbers: 1:1 practice for analysts who now draft their SQL with AI. Five stages on messy data with one planted error, so no total goes out unreconciled, ending when you catch the plant three sessions running.

• Eloise — How to Build an AI Agent That Stops

  How to build an AI agent that finishes, taught 1:1 by an AI tutor that reads your own run traces. Five stages from tool design to loop detection, ending when your agent handles ten varied inputs with no infinite loop and no silent tool failure.

• Elowen — CORS Error: Browser, Server or Preflight

  A CORS error tutor for developers who already added a proxy, a wildcard and three headers and are still blocked. Four stages on preflight, credentials and wildcards, worked from your real console text, until you name the wrong side of the wire in five minutes.

• Elsie — Claude Code, Without Wrecking Your Repo

  A Claude Code tutorial rebuilt as 1:1 practice on your own repository with paying users. Five stages on scoping, context discipline, checkpoint commits and reviewing a diff like a reviewer, ending when you reject a bad diff unprompted.

• Emil — Cursor AI Tutorial: PRs That Pass Review

  Cursor AI tutorial for engineers moving off VS Code whose AI-written pull requests keep bouncing in review. 1:1 work through real tickets in your own repo, with the diff critiqued as a teammate would, until two consecutive PRs land without rework.

• Emlyn — Power BI for Beginners: Dashboard in a Week

  Power BI tutorial for beginners, run 1:1 against your own ugly spreadsheet rather than a tidy sample file. Seven daily steps from Power Query to the director dry run, ending when every headline figure reconciles and you can explain each DAX measure.

• Emmanuelle — Git Merge Conflict Rescue

  Git merge conflict rescue as 1:1 practice, one safe command at a time, with a backup branch created before you touch anything. Five stages covering rebase, detached HEAD, reflog and undoing a bad force-push, until you recover three unfamiliar broken repositories with no destructive command.

• Enid — Pandas for Excel Users: VLOOKUP to Merge

  Pandas for Excel users who think in nested VLOOKUPs and pivots, taught 1:1 by translating each Excel move you already know. Five stages from groupby as a pivot table to merge as VLOOKUP with row counts, ending when you rebuild your real monthly report.

• Enrique — Automate the Boring Two Hours With Python

  Learn to automate the boring stuff with Python 1:1, with a tutor that reads your real files and your actual traceback. Built for non-developers losing two hours a month to renaming and merging; ends when the monthly job runs unattended twice.

• Eoin — SQL for Data Analysis: Pull Your Own Numbers

  SQL for data analysis, built for spreadsheet-first analysts: 1:1 reps against one real schema, not a video playlist. Five stages from joins that multiply rows to CTEs, ending when you answer three unfamiliar business questions without raising a ticket.

• Ephraim — TypeScript for JavaScript Developers: Kill the Any

  TypeScript for JavaScript developers who still reach for any, taught 1:1 from your own compiler errors. Five stages on narrowing, generics and utility types instead of casts, ending when you have removed ten anys and can say what each was hiding.

• Erasmus — Vibe Coding to a Live App

  Vibe coding rebuilt as 1:1 practice for non-engineers whose AI-generated prototype now needs real users on it. Six stages covering where your data lives, login, keys out of the front end and backups, ending when ten real users are on it and nothing is exposed.

• Erin — Async Await in JavaScript: Order and Promise.all

  Async await JavaScript for developers whose logs print out of order and whose functions return a Promise instead of a value. 1:1 tracing of your own snippets, sequential versus Promise.all, ending when you get five unfamiliar ordering puzzles right in a row.

• Ernesto — Build an MCP Server Agents Cannot Misuse

  An MCP server tutorial for API engineers wiring their first tool into an agent, taught 1:1 through adversarial role-play. Six sessions on transport, least privilege, auth and rate limits, ending when three different agents finish a task with no destructive call.

• Esperanza — Data Cleaning in Python: The Friday Number

  Data cleaning in Python, taught 1:1 by a tutor that argues the opposite side until your reasoning holds. Five sessions on a 40,000-row export with merged headers, four date formats and duplicate customers, ending with the number and every assumption written down.

• Estela — Learn Go Programming After Python and Node

  Learn Go programming with an AI tutor that names the Python and Node habits you carry in, not another video course. Six weeks from errors as values to channels and context, ending when your own consumer runs an hour under the race detector with zero findings.

• Ethan — Prompt Engineering for Developers on Legacy Code

  Prompt engineering for developers working in an eleven-year-old monolith, not a toy repo, taught 1:1 by transcript autopsy. Five sessions on task briefs, pinned constraints and tests as the contract, ending when three consecutive agent tasks land with no unrelated edits.

• Etienne — Build RAG Over Your Company Documents

  A RAG tutorial that measures retrieval instead of vibes, taught 1:1 over your own handbooks, tickets and contracts. Six sessions on chunking, hybrid retrieval, reranking and grounding, ending when your pipeline answers eighteen of twenty questions with a correct citation.

• Eugenie — How to Read a Stack Trace

  How to read a stack trace, with a 1:1 AI tutor that withholds the answer and asks which frame is yours. Five sessions from reading bottom up to async and threaded traces, ending when you diagnose five unseen traces without pasting them anywhere.

• Eva — Regex You Can Still Read in Six Months

  A regex tutorial that keeps score and shows the exact character where your pattern failed, run 1:1 as drill work. Six sessions through greed, boundaries, lookaround and catastrophic backtracking, ending when you pass twenty unseen drills first time.

• Evander — Beat the Rust Borrow Checker

  The Rust borrow checker for developers who failed at Rust twice: 1:1 work from the compiler's own annotated message. Six sessions from move semantics to Rc and RefCell, ending when you fix ten unseen borrow errors without cloning your way out.

• Evita — SQL Window Functions for Analyst Interviews

  SQL window functions for analysts who still export to Excel, marked 1:1 against a real orders and customers schema. Five sessions on partitions, frames, rank versus dense rank and lag, ending when you answer eight interview questions in under ten minutes each.

• Ewan — Build an AI App and Charge for It

  Build an AI app with a 1:1 tutor that holds you to something shipped every week, not another course. Eight weeks from cost per call and prompt injection to billing and launch, ending when a stranger has paid and your cost per call is written down.

• Ezra — Spring Boot for Enterprise Backend Interviews

  A Spring Boot tutorial rebuilt for bank and insurer backend interviews, with 1:1 spoken questions on every annotation you wrote. Seven weeks building one slice of a payments service, from beans to JPA N plus one, until you debug a failed context start unaided.

• Fabian — Why Your Docker Container Exits Immediately

  Docker container exits immediately, diagnosed 1:1 from your own logs and exit code rather than two more hours of Dockerfile edits. Four sessions on exit codes, compose networking and works-locally-dies-in-CI, ending when you diagnose three unseen containers in ten minutes.

• Fadi — LLM Evals That Catch Regressions

  LLM evals, taught 1:1 by a tutor that scores your cases independently and argues every mismatch until the rubric is unambiguous. Five sessions to a fifty-case golden set and a CI regression gate, ending when your judge matches your labels on forty of fifty.

• Faisal — Your First GitHub Actions Pipeline

  Your first GitHub Actions tutorial run 1:1 against your own workflow file and failing run log, not a sample repo. Five sessions from triggers and secrets to deploying on merge, ending when a pull request runs your tests in under four minutes.

• Farida — dbt Models, Refs and Tests for Analysts

  A dbt tutorial for analysts whose team just moved 200 ad-hoc queries into models, refs and tests. Six sessions reviewed 1:1 like a pull request, asking is this staging or a mart, until your project builds clean with a primary key test.

• Fatou — Workflow Automation That Does Not Fire Twice

  Workflow automation tools for operations coordinators with no coding background whose n8n and Zapier runs fire twice or fail silently. Five 1:1 sessions reading real run histories, ending when your three critical automations each have a failure alert and a deduplication key.

• Faye — Statistics for Data Analysis, Defended Out Loud

  Statistics for data analysis, taught 1:1 by an AI tutor that argues back like a sceptical product director. Six sessions from p-values to showing uncertainty on one slide, ending when you defend a real result for ten minutes without overclaiming.

• Federica — Power BI vs Tableau: The Translation

  Power BI vs Tableau for analysts with an interview in three weeks: 1:1 translation, not a beginner course. Four sessions map DAX measures onto calculated fields and Power Query onto extract filters, until you rebuild your own report and answer ten spoken interview questions.

• Felicity — RAG vs Fine Tuning: Make the Call

  RAG vs fine tuning, decided 1:1 with an AI tutor that takes the opposite side and demands your numbers. Four sessions pricing context engineering, retrieval and a LoRA fine-tune against your own traffic, ending in a one-page recommendation with cost per thousand requests.

• Livia — Internal Tools, No Code: Your Approval Queue

  Internal tools no code builders can carry in production, taught 1:1 to ops leads told engineering has no capacity this quarter. Five sessions from the approval record to row-level permissions, ending when ten real approvals run through a queue they built in Retool.

• Llewellyn — How to Write Unit Tests for Legacy Code

  How to write unit tests for legacy code, 1:1 with a tutor that rejects tests which only assert a mock was called. Four weeks on characterisation tests, seams and database fakes, ending when a pull request fails loudly on changed behaviour.

• Lorcan — Threat Modeling a New Endpoint Before You Build

  Threat modeling for product engineers with no security team: 1:1 practice against a tutor that argues the attacker side every time. Four sessions from data flows and trust boundaries to STRIDE on one endpoint, ending with five ranked threats, each with an owner and a mitigation.

• Moira — Data Literacy Training: Break the Dashboard

  Data literacy training rebuilt as 1:1 practice with a tutor that lets managers get caught before it explains anything. Five sessions on denominators, cohorts, truncated axes and rate versus count, built from your own metrics and done when four of five planted flaws are caught unaided.

• Rebekah — Beginner Python: Debug Your Own Code

  Python for beginners rebuilt as 1:1 debugging practice for CS1 students who can run code they cannot read. Six units with a tutor that points at the region and never pastes a fix, ending when a student explains three unseen bugs unaided, ten minutes each.

• Regina — Pointers in C: Find the Segfault

  Pointers in C for students comfortable with Java references and lost the moment memory is theirs to manage. Five units from malloc and ownership to reading Valgrind output, with a tutor that will not produce one corrected line, ending at three memory bugs located unaided.

• Reidar — Recursion in Programming: Trace the Stack

  Recursion in programming taught by making first-year computer science students narrate the call stack aloud. Five units from base cases to backtracking, with a tutor that never traces their graded problem, ending at an unseen recursive function traced without writing code.

• Remi — R Programming for Data Analysis: Thesis Data

  R programming for data analysis, taught 1:1 to masters and PhD students by a tutor that will not write the script. Six units from dplyr tidying to ggplot layers, run on a student's own thesis data, ending when they explain every line unprompted.