Skills you hand to your AI go dull.

Whetstone is a private practice space that runs on your machine. Your own coding agent writes real-world problems around your work, real tests grade them, and every idea you solve comes back before it fades.

Get Whetstone on GitHub See the quick start

Whetstone beside an AI agent. The learner presses Prepare, the agent builds a caching question, the learner guesses and runs the tests, a hidden test fails, the agent asks a question at line 13, and the fix passes every test. — One session, start to finish: press Prepare, your agent builds the question, a hidden test fails, the agent asks one question at the line that matters, and the fix passes.

Learn what you don't know.

Pick a system you want to understand, or a topic your next role needs. Your agent writes it as a series of steps, each a little harder than the last, starting from what you already know.

Relearn what you do.

The things you learned years ago, or now hand to your AI, fade quietly. Whetstone brings them back as fresh problems, so you find out what is still there.

Keep every skill sharp.

Each skill shows how sharp it is today. Solved ideas return on a new surface after 3 days, 3 weeks, 3 months, 6 months and a year.

Built to sit beside Claude.

Whetstone is written for the built-in browser of Claude's desktop app. The app runs in the side pane, your Claude session runs next to it, and the session watches you work and answers in your editor's margin. It works just as well with any coding agent that can run commands in a folder, such as Codex or Cursor.

Claude's desktop app with two panes. On the left, a Claude session: the learner asks whether a reorder buffer should be a dict or a heap, and whether dict.pop raises on a missing key. When two hidden tests still fail, Claude declines to write the fix and asks one question about line 15 instead. On the right, Whetstone in the built-in browser: the question Put the price updates back in order, the learner's code, 6 of 8 tests passed, and Agent connected in the header. — Claude beside Whetstone. On the left, the session answers Python questions in full, but when two hidden tests fail it asks one question about line 15 instead of writing the fix. On the right, the question in the built-in browser, with the agent connected.

You choose how much it says.

The pair mode sits under your editor. Your session follows it.

Sized for the pane: Designed at 820 pixels wide, in Claude's own neutral colours, light and dark, so it reads as part of Claude. It also works full screen and on a phone.
Buttons that reach your session: Prepare, Ask for review and Follow this path queue work for your agent. Prepare turns into Start when the question is ready.
A session that starts itself: Opening Claude Code in the folder shows what is due today. The optional mod keeps the watch running and puts your reviews in the status line.
It tutors, it doesn't type: A guard hook stops your agent before it writes to your progress or to a solo question's folder.
Not only Claude: Every agent drives the same plain command line, on the subscription you already have, and the app opens in any browser tab.

One idea, set in the world you work in.

Three engineers ask their agents for the next question in the rate limiter module. Each one practices the same idea in the world they already know. Pick an engineer.

rate-limiter, next questionthe idea: a token bucket

Nothing to fill in.

Your agent already knows you from the work you've done together: what you build, your stack, where you're headed, and what it now writes for you. It drafts your profile from that, and from your GitHub activity if you agree. You only check the draft.

Or set it in a company's world.

Press Prepare and choose your own work, a company you're preparing for, or a domain. Before an interview at Uber, the same rate limiter question can come back built on the questions Uber candidates report. Both versions stay, each with its own progress.

Prepare this for: Your own work, a company you're preparing for (your targets first, then the companies that ask this module most), or a domain. — **Prepare this for.** Your own work, a company you're preparing for (your targets first, then the companies that ask this module most), or a domain.

Prepare again for: The same idea set in another world. Every version stays, with its own progress, linked from the others. — **Prepare again for.** The same idea set in another world. Every version stays, with its own progress, linked from the others.

The question bank is grounded in 2,500+ interview reports from ~400 companies, organised into 250+ modules and ~80 systems to build.

Systems, not puzzles.

A learning path is an ordered list of modules toward one system. Ledgers that must balance, retries that must not charge twice, rate limiters, caches and schedulers.

Payments and fintech: payment processor, checkout, wallet, crypto exchange
Trading and markets: high-frequency trading, matching engine, risk, backtesting
Marketplaces and mobility: taxi booking, meal delivery, hotel booking, flash-sale tickets
Social and media: news feed, short-video feed, video and music streaming
Messaging: chat, video calls, collaborative docs, email
AI and developer platforms: an LLM gateway, LLM serving, RAG, CI, SSO
Data and infrastructure: data warehouse, Kafka-style log, object storage, databases
And further out: search, maps, CRM, payroll, vehicle updates, fab scheduling

The Paths page: each path's modules drawn as a route of stops, filtered to the paths that suit the learner. — Paths. Each one is a route of stops; filter by what suits you, what is ready now, a domain or a company.

One path: The modules in order, with the companies it is modelled on. Prepare all queues them, so you start the first while your agent prepares the rest. — **One path.** The modules in order, with the companies it is modelled on. Prepare all queues them, so you start the first while your agent prepares the rest.

Every stop: Point at a stop to see the module, where you are with it, and what it covers. — **Every stop.** Point at a stop to see the module, where you are with it, and what it covers.

Catalog: Every problem companies ask, with the reports behind it, most asked first. — **Catalog.** Every problem companies ask, with the reports behind it, most asked first.

Practice exactly what your AI now does for you.

Building from a blank file is one question type among eight. The rest train what assisted work wears down: reading, predicting, debugging and judging generated code.

What your AI does for you	What you practice in Whetstone
Writes the code	BuildThe problem comes first. The lesson opens after your first try.
Explains code you didn't write	PredictRead working code and say what it does before you run it.
Finds the bug	FixA bug report with symptoms, never the cause.
Reviews its own pull request	ReviewFind the defects planted in plausible AI-written code.
Writes the tests	TestsYour tests must catch hidden bugs you never see.
Sketches the architecture	DesignDraw it on a whiteboard. Your agent grades it against a rubric.
Works through a whole task with you	AI-allowed roundsA small codebase, solved in stages with the AI tool you use at work. Then, with the AI closed, you say what your code returns.
Writes the one-liner	TerminalText pipelines, jq and git rescues in a sealed shell. Your script is replayed on scenarios you never saw.

Nine finished questions ship in the repo.

They set the quality bar your agent writes to. Each opens on GitHub, with its problem, hints, tests and the wrong solutions the tests must catch.

A question at full screen: the problem on the left, the editor on the right with a failing hidden test and a note from the agent at line 13 asking what the line does when the saved value is 0. — Eight of nine tests pass. The hidden one names the scenario, not the answer, and your agent asks one question at line 13.

One question, four moments.

Guess first: Before your first run, you guess which tests will pass. Predicting is how reading code sticks. — **Guess first.** Before your first run, you guess which tests will pass. Predicting is how reading code sticks.

The problem, beside your code: Each section of the problem opens over the editor, so you read it without leaving your code. — **The problem, beside your code.** Each section of the problem opens over the editor, so you read it without leaving your code.

A note from your agent: A hidden test fails. Your agent, watching, asks one question at the line that matters. — **A note from your agent.** A hidden test fails. Your agent, watching, asks one question at the line that matters.

Solved: Every test passes. You explain one hidden case in your own words, and a variant comes back in 3 days. — **Solved.** Every test passes. You explain one hidden case in your own words, and a variant comes back in 3 days.

Help climbs one rung at a time.

The same agent that writes your questions tutors you without giving the answer away. The next rung unlocks only after a new test run.

A question about the failing behaviour.
The concept behind it.
A concrete next step, tied to a named test.
A skeleton with the key lines blank.

Graded by tests that were tested.

Before a question reaches you, Whetstone checks that its reference solution passes, its starter fails, and every wrong version of the solution is caught. Visible tests check the basics. Hidden tests check the edge cases.

Before your first run you guess which tests will pass. After a solve you explain one hidden case in your own words.

Talk to your agent in plain words.

"What should I practice next?": It reads your progress and offers two choices. Reviews that are due come first.
"Make me a path to build a checkout system.": It proposes an ordered list of modules, or finds a shipped path that fits.
"I'm stuck on rate-limiter/02.": It runs your code, then helps one step at a time. It doesn't write your solution.
"Pair with me as an interviewer.": It watches you work and asks one question at a time in your editor's margin.
"Review my solution.": Up to three comments, most severe first, each with the principle, the evidence and a next step.
"Interview me on system design.": It runs a mock interview and scores you against a rubric.

System design, on a real whiteboard.

Write the design, draw it with boxes and arrows, and ask for a review. Your agent grades each rubric point with a quote from your own design. A missed point shows only a question until you pass.

Design: System design questions from 200+ interview reports, most asked first. — **Design.** System design questions from 200+ interview reports, most asked first.

Whiteboard: Draw the design with boxes and arrows. No diagram syntax to learn. — **Whiteboard.** Draw the design with boxes and arrows. No diagram syntax to learn.

Preview: Your sections, plus the drawing exactly as your agent reads it. — **Preview.** Your sections, plus the drawing exactly as your agent reads it.

Review: Each rubric point graded with a quote from your design. — **Review.** Each rubric point graded with a quote from your design.

Every solved idea comes back.

Not the same question. A variant: the same idea on a new surface, 3 days later, then 3 weeks, 3 months, 6 months and a year. Drag through the year to see what that does to an edge.

Since you solved it

With Whetstone's reviews

Left alone

The curve is an illustration of spacing, not a measurement of you. The schedule is the real one. A clean review lengthens the gap; a failed one shortens it to 2 days.

Grit ranks, like the stones.

The game layer rewards mastery, never volume. No points, no leaderboards, and you can hide it.

220Started.
1000Solved.
3000Solved on your own, no last hint, no peeking.
6000Mastered: a spaced variant also passed when it came due.
8000Still sharp after a long review.

The weekly streak asks for 3 practice days and forgives a missed week. When it breaks you see your total practice days, never "streak lost".

Today: your next step, when your next review is due, and each skill with an edge showing how sharp it is.

Progress: practice days, milestones and personal records.

Built on evidence, and it says how strong.

Thirteen teaching rules sit behind every question: problem before lesson, a gated hint ladder, feedback on the work and never the person, deterministic concurrency tests. Each one cites its studies and rates the evidence as strong, moderate or weak.

Read how Whetstone teaches

Yours, on your machine.

No account and no telemetry. Whetstone has no AI of its own: your agent writes the questions on the subscription you already pay for, and Whetstone checks and grades them locally.

Quick start

You need Docker and an AI coding agent that can run commands in a folder: Claude Code, Codex, Cursor or another.

four commands

git clone https://github.com/boffti/whetstone && cd whetstone
cp .env.example .env
docker compose up -d --build   # then open http://localhost:8000
claude                         # or codex, or open the folder in Cursor

Then tell your agent: "Set up my Whetstone profile." If something doesn't work, bin/whetstone doctor checks the setup and says how to fix each problem. Exercises are Python 3.12 today.

Your work never leaves `my/`.

Your questions can mention your job, so they stay with you. A git pull brings new paths and research without touching them.

`whetstone/ bin/`	committed	The app and the command line
`content/`	committed	The shared catalog and learning paths
`examples/`	committed	Finished questions that set the quality bar
`my/`	never	Your profile, questions, paths, drafts and progress

What's next

Build, predict, fix, review, tests and design questions, with mutation-checked tests
Requests from the app to your agent, and live pairing in the editor's margin
System design on a whiteboard, graded against a rubric
Terminal questions in a sealed shell, graded by replaying your script
More tool packs: sqlite3, kubectl, Terraform and the AWS CLI on a local fake
More languages: TypeScript and Go, chosen from your profile

Open source, and open to you.

New learning paths, modules, paraphrased interview research and app improvements are all welcome. Questions themselves are personal, so they stay out of the repo.

Get Whetstone on GitHub Read the contributing guide