voltabenchRequest an invitation

Not another AI tutor

Watch your logic run.

The foundation for logic literacy: say what you mean as steps, in a diagram or in code, and watch it run.

voltabench sees every block you place, every step your program takes, every line you write. When something goes wrong, it says what and where, on the spot.

Generative AI can hand you the answer. It cannot tell you what you did wrong, because it never saw you build it. voltabench did.

Request an invitation Try the board

Backed by research · Built in the classroom · A decade of student work · Free this school year

checkout flow · assignment 4Ready
Test case: a price of 240 should print Priority

Read the board, then make the call

A price of 240 came in, so total is 240. The diamond asks: is total more than 100? Which way does it go?

no signup needed

CONSOLE
nothing printed yet
VARIABLES
no values yet

Live from the bench: what voltabench has already seen and explained

45,300

mistakes explained on the spot, in plain language

30,200

steps explained, every value on screen

3,600

runs watched, diagrams and code

1,000

hours of student building seen

Counted from real student work. Updated every hour.

01 · What voltabench sees

It sees the whole build, not just the answer.

variable · total
total = {{total}} + {{last}}
total = 10 + 5
total = 15 NUM
Every calculation, one step at a time7,400+ values computed so far
condition · qualifies?
score >= 60 and attended
58 >= 60 falseattended never ran
No
Once the first part is false, the rest never runs, and the screen says so4,800+ decisions explained so far
console
a = "5" STR
b = "9" STR
a + b → "59" STR
5 + 9 → 14 NUM
Text sticks together, numbers add up, and the screen tells you which is which5,400+ lines printed so far
repeat · once for each order
pass 12345
total = 340 · all five orders
Watch the loop go round, once for each order5,800+ loop passes watched so far

Most tools tell you the result. voltabench shows the reasoning.

Backed by research

Built on how people learn to program. By name.

  • Multiple representations

    Diagram, code, live values and plain words, side by side.

    Ainsworth 2006

  • Concreteness fading

    Blocks first, then the same program in code. Same engine, same tests.

    Goldstone & Son 2005 · Weintrop & Wilensky 2017

  • The notional machine, visible

    Every step and every value on screen. Nothing happens unseen.

    du Boulay 1986 · Sorva 2013

  • Cognitive load, managed

    One thing moves at a time, and you hold the clock: pause, step, replay.

    Sweller 1988 · Mayer & Chandler 2001 · de Koning et al. 2010 · Tversky et al. 2002

  • Predict, observe, explain

    Read the board, make the call, watch it run, read why.

    White & Gunstone 1992 · Naps et al. 2002 · Hundhausen et al. 2002 · Byrne et al. 1999

  • Worked examples

    See it run: the solution, live on your own input, step by step.

    Sweller & Cooper 1985

  • Misconception-targeted feedback

    Each explanation targets a documented novice misconception, not a generic hint.

    Qian & Lehman 2017 · Ben-David Kolikant & Mussai 2008

  • Formative feedback

    On the spot, about the step, in words you can act on. Not a score.

    Black & Wiliam 1998 · Hattie & Timperley 2007

Before the first animation was drawn, we surveyed 0 published studies of program visualization. In none of them is the mistake explained on the student's own program, at the step it went wrong. On the bench it is. The rest came from more than a decade of teaching people to program, thousands of real programs and mistakes, and design-based research: the people who built it teach with it every week.

Read the references
  • Ainsworth, S. (2006). DeFT: A conceptual framework for considering learning with multiple representations. Learning and Instruction, 16(3).
  • Goldstone, R. L., & Son, J. Y. (2005). The transfer of scientific principles using concrete and idealized simulations. Journal of the Learning Sciences, 14(1).
  • Weintrop, D., & Wilensky, U. (2017). Comparing block-based and text-based programming in high school computer science classrooms. ACM Transactions on Computing Education, 18(1).
  • du Boulay, B. (1986). Some difficulties of learning to program. Journal of Educational Computing Research, 2(1).
  • Sorva, J. (2013). Notional machines and introductory programming education. ACM Transactions on Computing Education, 13(2).
  • Sweller, J. (1988). Cognitive load during problem solving: Effects on learning. Cognitive Science, 12(2).
  • Mayer, R. E., & Chandler, P. (2001). When learning is just a click away: Does simple user interaction foster deeper understanding of multimedia messages? Journal of Educational Psychology, 93(2).
  • de Koning, B. B., Tabbers, H. K., Rikers, R. M. J. P., & Paas, F. (2010). Attention guidance in learning from a complex animation: Seeing is understanding? Learning and Instruction, 20(2).
  • Tversky, B., Morrison, J. B., & Bétrancourt, M. (2002). Animation: Can it facilitate? International Journal of Human-Computer Studies, 57(4).
  • White, R. T., & Gunstone, R. F. (1992). Probing Understanding. Falmer Press.
  • Naps, T. L., et al. (2002). Exploring the role of visualization and engagement in computer science education. ITiCSE Working Group Report; ACM SIGCSE Bulletin, 35(2).
  • Hundhausen, C. D., Douglas, S. A., & Stasko, J. T. (2002). A meta-study of algorithm visualization effectiveness. Journal of Visual Languages and Computing, 13(3).
  • Byrne, M. D., Catrambone, R., & Stasko, J. T. (1999). Evaluating animations as student aids in learning computer algorithms. Computers & Education, 33(4).
  • Sweller, J., & Cooper, G. A. (1985). The use of worked examples as a substitute for problem solving in learning algebra. Cognition and Instruction, 2(1).
  • Qian, Y., & Lehman, J. (2017). Students’ misconceptions and other difficulties in introductory programming: A literature review. ACM Transactions on Computing Education, 18(1).
  • Ben-David Kolikant, Y., & Mussai, M. (2008). “So my program doesn’t run!” Definition, origins, and practical expressions of students’ (mis)conceptions of correctness. Computer Science Education, 18(2).
  • Black, P., & Wiliam, D. (1998). Assessment and classroom learning. Assessment in Education: Principles, Policy & Practice, 5(1).
  • Hattie, J., & Timperley, H. (2007). The power of feedback. Review of Educational Research, 77(1).
  • Design-Based Research Collective (2003). Design-based research: An emerging paradigm for educational inquiry. Educational Researcher, 32(1).
  • Wing, J. M. (2006). Computational thinking. Communications of the ACM, 49(3).
  • Siemens, G. (2013). Learning analytics: The emergence of a discipline. American Behavioral Scientist, 57(10).

02 · Blocks and code

Start with blocks. Finish with code.

Every block is a real programming idea: a variable, a choice, a loop. Build with blocks first, then write the same logic as code in the same bench, each value shown beside its line. Two notations, one way of thinking.

checkout flow · same program, two waysSame engine · same test cases · same grade

BLOCKS

CODE · C#

1int price = int.Parse(Console.ReadLine());price = 240
2int total = 0 + price;total = 240
3if (total > 100)240 > 100 · true
4{
5 Console.WriteLine("Priority");prints Priority
6}
7else
8{
9 Console.WriteLine("Standard");skipped
10}
Test case 1 passedinput 240 · expected Priority · got Prioritygraded the same way in blocks and in code

One decision, every language.

Logic literacy is not tied to a language. The diamond from the first screen is one line in every language you will ever meet, and here the diagram is not a picture of it. It is the logic, running.

THE SAME DECISIONtotal > 100 → "Priority"
Python
if total > 100: print("Priority")
JavaScript
if (total > 100) console.log("Priority")
Java
if (total > 100) System.out.println("Priority");
Go
if total > 100 { fmt.Println("Priority") }
SQL
CASE WHEN total > 100 THEN 'Priority' END
C#
if (total > 100) Console.WriteLine("Priority");

03 · For instructors

Walk into tomorrow's class knowing exactly what to reinforce.

Learning analytics on the build itself, not on quiz scores: who is stuck, on which idea, and what the class keeps getting wrong, before you grade a thing.

  • Who to talk to, and about what. The students struggling this week and the exact idea they are stuck on, read from their own builds.

  • What to re-teach. The concepts the class keeps getting wrong, ranked for tomorrow's first ten minutes.

  • How an answer came together. Sessions replays one student's build, block by block.

  • Every grade explained. Test cases, expected next to got, in a report the student can read. A full course comes with it.

  • The admin, handled. Canvas sync with a preview, per-student extensions, gradebook export.

  • Student work stays your school's. Education records; no AI reads or grades them. Privacy policy.

grade all · Loops: batch orderssample class
S. Whitfield100
J. Reyes60
CASE 3 · 5 ORDERS · DID NOT PASS
expected
total = 340
got
total = 85

The total was set back to 0 inside the loop, so only the last order counted.

A. Chen80
P. Nair100
30 / 30 graded · same test cases for everyoneevery grade opens to the cases behind it
0+

times a week a typical student runs their own work. Every run is another step explained.

WHAT TO RE-TEACH · THIS WEEK sample
  1. Resetting the total inside the loop · 6 students
  2. Text where a number was needed · 4 students
  3. A branch that never runs · 2 students
Request an invitation Email us: support@voltabench.com

04 · Why it matters

The answer is free now. Understanding is not.

Any student can get a working program from a chatbot in ten seconds. What they cannot get is a reason they got it wrong, because the chatbot never saw them try. voltabench did. What stays is logic literacy, the beginner's end of computational thinking: know what you want, break it into steps, check the result.

FADING

  • Typing code by hand
  • Memorizing commands
  • Copy-paste setup code
  • Hunting for a missing semicolon

STAYING

Steps
turning a fuzzy goal into clear steps, in order
Saying what you mean
every prompt you will ever write uses this skill
Checking
testing the answer against real cases, not by how it looks
Data sense
knowing what a filter or a choice does to your data

The evidence

Someone already tested this.

About a thousand students were split into three groups: one used ChatGPT, one used an AI tutor that gave hints instead of answers, and one used a textbook. With the AI on screen, both AI groups pulled far ahead. Then the AI was taken away and everyone took the same exam.

On that exam, how did the ChatGPT group do compared with the textbook group?

The engine does exactly what you say. That is how you learn to say exactly what you mean.

Read the sources
  • Bastani et al. PNAS 2025 · pre-registered randomized trial · about 1,000 students · the study above
  • Hundhausen, Douglas & Stasko JVLC 2002 · meta-study of 24 experiments: how students use a visualization matters more than what it shows them
  • Kosmyna et al. 2025 · EEG preprint · 54 people
  • Lee et al. CHI 2025 · survey of 319 knowledge workers

Only the first is charted. The others are smaller, self-reported, or qualitative, and sharing an axis would lend them a precision they do not claim.

05 · Questions

Fair questions, straight answers.

Something missing? support@voltabench.com

Anyone learning to express logic clearly, starting from zero: say what you want as steps, in a diagram or in code, and see whether it works. It runs in the browser, nothing to install. Our rule for every screen: if a middle schooler could not follow it, we redo it.

Signing in with Google is one way to create your voltabench account. It reads your name, email address, and profile picture, and nothing else. Your email is matched against your course invitation so you land in the right class; your name and picture appear on your own dashboard and on your instructor's roster. Nothing is written back to your Google account, and none of it is sold or shared. Full detail in the privacy policy.

The bench is open

Build it. Run it. Know it is right.

The foundation for logic literacy: it sees how students build, explains every mistake on the spot, and tells you what to teach tomorrow. Free for students this school year.

Request an invitation 0+ mistakes explained on the spot so far, and counting

Learning on your own? Join the list.