Get on a call with an AI that teaches code like a senior engineer.

Not a chat box. It talks you through it, shows you in your own code, and no question is too basic.

Free to try: 10 minutes of calls, no card.

src/components/PayButton.tsx

1'use client';
2
3import { useState } from 'react';
4import { Button } from '@/components/ui/button';
5
6export function PayButton({ total }: { total: number }) {
7 const [busy, setBusy] = useState(false);
8
9 async function pay() {
10 setBusy(true);
11 const res = await fetch('/api/checkout', { method: 'POST' });
12 const { url } = await res.json();
13 window.location.href = url;
14 }
15
16 return (
17 <Button onClick={pay} disabled={busy}>
18 Pay ${total}
19 </Button>
20 );
21}

How an order travels

Pay button
/api/checkout
Stripe
Stripe webhook
orders table

Codeplain

On the call

3:12

Ask the question you would be embarrassed to ask.

With a teacher, most people nod along rather than admit they are lost. Here nobody is keeping count. Ask what a variable is. Ask the same thing a fifth time. Say “slower”. It never sighs, never rushes you, and never makes you feel behind.

Sorry, what is an API again?
Why is it called a function?
Can you explain that one more time, slower?
What does async actually mean?
Is it bad that I don't understand my own app?

It shows you while it talks.

Chat gives you an answer to paste. A call makes sure you understood it. Everything Codeplain explains, it shows you: in your own code, or in an example it writes on the spot.

checkout7 matches in 214 files

src/components/PayButton.tsx:14router.push('/api/checkout')
src/app/api/checkout/route.ts:13stripe.checkout.sessions.create({
src/app/api/webhooks/stripe/route.ts:7event.type === 'checkout.session.completed'
src/lib/cart.ts:22export async function getCart(req: Request)

Your own app becomes the lesson.

Built it with Lovable, Cursor, Bolt, v0, Replit or Claude Code? Connect it from GitHub and Codeplain searches every file, reads any of them and follows an import to where the work happens. You learn on the code you are building, not a textbook example.

8 const cart = await getCart(req);
9 if (cart.items.length === 0) {
10 return NextResponse.json({ error: 'Cart is empty' });
11 }

What's this?

A guard. If the cart is empty it stops here, so nobody is sent to pay for nothing.

It sees what you select.

Highlight a few lines and ask “what’s this?” — nothing else to explain.

1The front door src/app/page.tsx
2Where the cart lives src/app/cart/page.tsx
3Paying src/app/api/checkout/route.ts
4Saving the order src/app/api/webhooks/stripe/route.ts
5Where data lives src/lib/db.ts

It gives you a tour.

New to a codebase? It walks you through it stop by stop, opening each file while it talks.

It draws while it explains.

How a request travels, what happens on click, where the data goes: Codeplain sketches it on a whiteboard next to the code and points at each box as it gets there.

A call, not a chat window.

Talk the way you would to a colleague. Codeplain listens while it speaks, so you can interrupt, ask again, or say "slower". It speaks 21 languages, and your code stays as it is.

Codeplain

Speaking

4:52

So a component is a function that returns what should be on the screen. Props are the arguments you pass in, and state is—

Wait, slower. What's the difference between props and state again?

Good question. Props come from outside, like a setting someone hands you. State is a value the component keeps for itself and can change.

Open mic. Just talk.

It remembers you.

Your goal, what you have covered, what keeps tripping you up. Every call starts where the last one ended, and you can see what it wrote down.

Pick up where we left off

Learn JavaScript for debuggingStep 2 of 6

Now: Control Flow — write if/else statements and loops to direct program execution.

Continue

Last time (yesterday): Reviewed let and const; const immutability clicked. Next: control flow with if/else statements and loops.

Still tricky: reading error messages from the bottom up

How a call goes.

Twenty minutes is a good call. There is nothing to prepare; you bring the question, or the plan brings it.

You join
Codeplain greets you by name and picks up from last time. If it is your first call, it asks what you want to learn.
You talk
Ask anything, as often as you need. It answers out loud, opens the file, and points at the lines while it explains.
You try
When you want to: a small task in the shared editor, real output when you run it, and a question to check the idea landed. Or skip it and keep asking.
You leave
A recap of what you covered, what it will remember for next time, and exactly what the call cost.

Pay for hours, not tokens.

Try it free with 10 minutes of calls, to use within 30 days. Then pick how much call time you want. Typed questions cost seconds, and every call ends with a line that says what it took.

Pro$20 a month

about 90 minutes of calls a month. A couple of calls a week.

Max$49 a month

about 6 hours of calls a month. For a daily learning habit, or long sessions on your own app.

See what each plan includes

Most people learn to code alone, with a chat box and a lot of guessing. What works better is someone to talk it through with, who shows you on the screen and never minds the fifth “wait, why?”.

Irfan Rosandi, founder

Learn it out loud.

Bring a question, or bring the app you are building. Your first call is on us.

Free to try: 10 minutes of calls, no card.

Codeplain

Ready when you are

Voice call

You could start with

How does login actually work?
What is an API, really?
Why did my app break?

Or anything else. No question is too basic.