SAT Behavioral Learning Model

The SAT tutor that turns scattered work into one living Student Model, tests the next move, and checks again before calling it mastery.

Comment

Inspiration

I’m Joshua. I’m 15, and I built Elite1600 because of what I noticed while studying for the SAT.

I was using GPT, practice tests, and different websites, but none of them shared what they learned about me. Every time I switched tools, I started over. I also learned that a correct answer did not always mean I understood the idea. I could guess correctly once, then miss three later questions testing the same skill.

What actually helped my score was slower and more honest: inspect the mistake, understand the deeper reason, explain the principle in my own words, and then prove I could use it again. I wanted an SAT tutor with memory, but also with humility. It should remember evidence across tools, test what it thinks that evidence means, and refuse to call one lucky answer mastery.

What it does

Elite1600 turns scattered SAT work into one evidence-backed learning loop:

scattered evidence → verified Student Model → testable hypothesis → fresh authored question → targeted correction → later check

A student can bring screenshots, PDFs, text files, CSV practice history, copied notes, scores, and missed questions. GPT-5.6 extracts bounded, source-linked observations, but they are only proposals. The student can review, correct, include, or exclude them before anything changes training.

Plan converts the verified record into a Student Model covering 54 SAT skills. It keeps imported academic history separate from live behavior and makes uncertainty visible. Instead of diagnosing a student from an old miss, it chooses one supported opportunity and sends a precise hypothesis to Train.

Train then asks a fresh, authored question from that exact skill. Before revealing correctness, it captures the student’s answer, confidence, and reasoning. That matters because the same wrong answer could come from a misconception, a careless step, or uncertainty, while a correct answer could still be a lucky guess.

The authored answer key determines correctness. GPT-5.6 separately analyzes the complete question and behavior record to estimate what may have caused the response. The student can confirm, correct, or add uncertainty through a short reflection. When the evidence supports it, Train teaches the specific idea, asks the student to explain it back in their own words, and checks the idea on a different question.

That new evidence flows back into Plan. The updated Student Model shows what Elite1600 suspected, what the student demonstrated, and what still needs checking. One successful correction is useful, but it does not prove retention. Elite1600 brings the skill back after other questions before treating it as learned.

For the repeatable judge journey, Maya is a clearly labeled fictional student with nine inspectable synthetic sources. Her guided session stays isolated from normal account data and continues through verification, Plan, Train, an updated Plan, a later spaced check, and a Learning Receipt.

How I built it

During Build Week, I used Codex and GPT-5.6 to build Plan, Train, evidence importing, and the Student Model, then connect them into one working learning loop.

The product uses React 19 and Vite on the frontend, with Firebase Authentication, Firestore, Hosting, and Cloud Functions behind it. The AI paths use the OpenAI Responses API with GPT-5.6 Luna, strict Structured Outputs, bounded token budgets, timeouts, and store: false.

I deliberately kept high-stakes learning decisions outside the model. Deterministic code owns answer-key correctness, topic mapping, score ranges, question selection, evidence transitions, and mastery limits. GPT-5.6 handles the parts that benefit from reasoning across messy evidence: source-grounded extraction, possible-cause analysis, and rubric-based feedback on a student’s explanation.

Codex helped me turn the idea into tested product behavior. I used it to connect the exact Plan assignment to Train, design an isolated session that survives refresh and browser history, implement source-linked evidence review, build the Learning Receipt, test the complete judge journey, and polish the experience for a first-time student.

Challenges

The hardest challenge was not making the AI sound smart. It was making every conclusion inspectable and appropriately uncertain.

Imported notes cannot become live confidence or timing data. A tutor’s guess cannot silently become a confirmed misconception. A model judgment cannot override an authored answer key. One successful correction cannot become mastery. I built validation and fail-closed behavior around each of those boundaries.

The second challenge was continuity. Plan and Train are separate experiences, but the student should feel one coherent lesson. The handoff carries the exact skill, assignment reason, evidence IDs, exclusions, workout ID, and session ID. The same versioned demo session survives reloads, Back and Forward navigation, dense evidence, and delayed review without leaking into normal student state.

Accomplishments I’m proud of

  • A complete evidence-to-action journey, not a chatbot wrapper
  • Nine openable synthetic sources and a 54-skill Student Model for a repeatable judge demo
  • Fresh authored questions with deterministic correctness and strict mastery limits
  • GPT-5.6 analysis that stays bounded, structured, and separate from the answer key
  • A Learning Receipt that preserves before-and-after reasoning without pretending one correction proves mastery
  • Integration tests for the exact Plan-to-Train handoff, refresh recovery, evidence isolation, honest empty states, delayed review, and receipt generation

What I learned

The most important lesson was that trustworthy AI is partly about deciding what the model must not control.

GPT-5.6 made it possible to reason across evidence that does not fit neatly into a spreadsheet. Codex made it possible for me to build and test the surrounding system quickly enough to turn that reasoning into a real product. But the experience became credible only when uncertainty, provenance, and deterministic boundaries were visible to the student.

What’s next

Next I want to test Elite1600 with more students, measure whether the proposed next move actually improves later performance, and keep simplifying the experience for someone opening it with no explanation. The long-term goal is not to generate more SAT content. It is to build an increasingly evidence-backed model of how each student learns, so every new piece of evidence makes the next learning decision smarter.

Built With

Share this project:

Updates