Trapwise

Trapwise is an adaptive SAT style learning app that identifies why students miss questions, builds a personalized Mistake Twin, and creates targeted practice to help them recognize traps and improve!

Comment

Inspiration

Most test-prep apps tell students which questions they answered incorrectly, but they rarely explain why the wrong answer felt convincing.

Trapwise was created by inspiring me by the idea that wrong answers contain valuable information. When a student repeatedly selects a certain type of distractor, they may not simply lack knowledge. They may be falling for a recurring reasoning pattern, such as:

  • Solving for the wrong value
  • Using the wrong operation
  • Misreading a graph
  • Stopping one step too early
  • Choosing a tempting answer without verifying it
  • Repeating the same high-confidence mistake

I wanted to build an educational experience that detects these patterns and turns every mistake into targeted practice.

That idea became Trapwise’s central feature: the Mistake Twin, a profile of the traps a student is most likely to fall for.

Most test-prep apps show what you got wrong. Trapwise discovers why.

What it does

Trapwise is an adaptive SAT-style learning app that analyzes the patterns behind incorrect answers.

Its main learning loop is:

Practice → Detect → Train → Weaken
  1. Practice with original SAT-style questions.
  2. Detect the mistake pattern connected to the selected distractor.
  3. Train with a targeted follow-up question.
  4. Weaken the recurring pattern through focused correction.

After completing a diagnostic, students receive a Mistake Twin that can show:

  • Their dominant mistake pattern
  • A secondary mistake pattern
  • Their strongest and weakest skills
  • Confidence mismatches
  • Current pattern strength
  • Recommended counter-strategies
  • Targeted follow-up practice

For example, two students may miss the same problem while choosing different wrong answers for completely different reasons.

One student may use the wrong formula. Another may solve the problem correctly but report the wrong value. A third may misread information shown in a graph.

Trapwise uses those different answer choices as diagnostic evidence.

A simplified mistake-pattern score can be represented as:

$$ P_m = \frac{\sum_{i=1}^{n} w_i e_i} {\sum_{i=1}^{n} w_i} \times 100 $$

where:

  • (P_m) is the strength of a mistake pattern
  • (e_i) represents evidence that the mistake occurred
  • (w_i) represents factors such as confidence, difficulty, repetition, and recency

The pattern score remains between (0) and (100).

A high-confidence mistake may provide stronger evidence than a random guess. Correctly completing targeted follow-up questions can weaken the pattern, but one easy question cannot completely erase a repeated mistake.

Trapwise uses careful language such as:

Your answer pattern suggests...

and:

Your current Mistake Twin tends to...

This allows the app to provide useful feedback without claiming certainty about a student’s private thought process.

Trap Forge

Trap Forge reverses the normal question-answering process.

Instead of only selecting the correct answer, students study how believable wrong answers are created.

Depending on the activity, a student may:

  • Identify a plausible distractor
  • Create a wrong answer
  • Assign a mistake category
  • Explain why another student might select it
  • Learn how to recognize the same trap later

After submission, Trap Forge explains:

  • Why the distractor is plausible
  • Which mistake could create it
  • Why a student might choose it
  • How to avoid the same trap later
  • Whether it matches the student’s Mistake Twin

This teaches students to think like question designers instead of only test takers.

Judge Demo

Trapwise includes a deterministic Judge Demo that allows someone to experience the main product loop without creating an account.

The demo flow is:

Diagnostic
→ Mistake Twin
→ Targeted Follow-Up
→ Trap Forge
→ Progress

The demo uses clearly labeled fictional data and is designed to work without:

  • An account
  • Payment
  • A Supabase connection
  • An OpenAI API key
  • Personal student information

This gives judges and new users a reliable way to experience the central Trapwise idea in only a few minutes.

Additional features

Trapwise also includes:

  • Adaptive diagnostics
  • Daily Practice
  • Progress tracking
  • Trapwise Mastery
  • XP and player levels
  • Practice streaks
  • Achievements
  • A fictional demo leaderboard
  • Guest access
  • Optional accounts and cloud synchronization
  • Visual questions
  • Light and dark themes
  • Responsive mobile navigation
  • Local fallback behavior when external services are unavailable

How I built it

I built Trapwise as a full-stack web application using:

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS
  • Supabase
  • OpenAI GPT-5.6
  • Codex
  • Playwright
  • Vercel
  • GitHub
  • HTML
  • CSS
  • JavaScript

The application was designed so that its main educational experience does not rely entirely on external services.

Local learning engine

Trapwise includes a deterministic local learning engine that handles core features such as:

  • Diagnostic questions
  • Distractor-to-mistake mappings
  • Mistake Twin generation
  • Follow-up selection
  • Pattern-strength updates
  • Daily Practice
  • Local Trap Forge evaluation
  • Progress tracking
  • XP and achievements
  • Fictional leaderboard data
  • Guest-mode persistence

This allows the main experience to continue even when Supabase or OpenAI is unavailable.

Verified local answer keys remain the source of truth.

Question structure

Each question contains structured information such as:

  • Subject
  • Skill
  • Difficulty
  • Correct answer
  • Four distinct answer choices
  • Explanation
  • Fast strategy
  • Main trap
  • Mistake category for each distractor
  • Approval status
  • Visual data when required

This metadata allows Trapwise to understand more than whether the final answer was right or wrong.

Adaptive practice

Trapwise can adapt question selection using information such as:

  • Skill performance
  • Question difficulty
  • Recent mistakes
  • Dominant mistake patterns
  • Confidence levels
  • Previously answered questions

The goal is not simply to make questions harder or easier. Trapwise attempts to select questions that provide useful evidence about the student’s reasoning patterns.

Optional GPT-5.6 enhancements

GPT-5.6 is used for optional enhanced features where natural-language reasoning can add value.

These enhancements can include:

  • More detailed mistake explanations
  • Personalized learning feedback
  • Additional follow-up support
  • Nuanced Trap Forge evaluation
  • Student-friendly strategy explanations

AI does not control verified answer keys or directly decide official mastery values.

When AI is unavailable, Trapwise falls back to its deterministic local systems.

The app also communicates that:

AI feedback may make mistakes. Verified local answers remain the source of truth.

Supabase and accounts

Supabase supports optional cloud features such as:

  • User authentication
  • Cloud progress storage
  • Profiles
  • Cross-device persistence
  • Leaderboard information
  • Account-based learning history

Guest users can still access the main Trapwise experience without creating an account.

The fictional demo leaderboard does not expose:

  • Email addresses
  • Internal user IDs
  • Private Mistake Twin history
  • Authentication information
  • Personal student information

Progress systems

Trapwise separates different types of progress so that they are not confused with one another.

Trapwise Mastery

Trapwise Mastery is an internal learning estimate from (0) to (100).

It is not an official SAT score.

Pattern strength

Pattern strength estimates how strongly a recurring mistake appears in the student’s answer history.

XP and levels

XP and levels provide game-like motivation for completing learning activities.

Streaks

Streaks reward consistent practice without changing verified answer correctness.

Achievements

Achievements recognize milestones such as:

  • Completing a diagnostic
  • Correcting a recurring pattern
  • Finishing Daily Practice
  • Improving confidence calibration
  • Completing Trap Forge activities
  • Building a practice streak
  • Answering visual questions
  • Reaching improvement goals

These systems remain separate so that a high player level does not automatically represent high academic mastery.

Codex development workflow

Codex helped accelerate the development and refinement of Trapwise.

I used Codex to assist with:

  • Repository architecture
  • React and TypeScript components
  • Responsive mobile navigation
  • Diagnostic logic
  • Mistake Twin calculations
  • Local fallback behavior
  • Trap Forge validation
  • Accessibility improvements
  • Error and loading states
  • Browser-testing preparation
  • Security reviews
  • Documentation
  • Vercel deployment preparation
  • Production-readiness audits

I remained responsible for the product idea, feature decisions, educational direction, branding, testing choices, and final implementation decisions.

Challenges we ran into

Detecting why an answer was wrong

The largest challenge was moving beyond basic correctness.

It is easy to check whether an answer matches an answer key. It is much harder to connect each wrong answer to a meaningful reasoning pattern.

I addressed this by giving every distractor structured mistake metadata. This allows Trapwise to treat a wrong answer as evidence instead of only a lost point.

Keeping the Mistake Twin trustworthy

The Mistake Twin needed to feel useful without pretending to read a student’s mind.

I had to design the system so that:

  • One mistake does not create an extreme conclusion
  • Repeated mistakes provide stronger evidence
  • Confidence affects pattern weighting
  • Pattern scores remain between (0) and (100)
  • Correct follow-ups reduce patterns gradually
  • Missing data is handled safely
  • The app communicates uncertainty honestly

Making AI optional

I wanted GPT-5.6 to improve the experience without making the entire application dependent on paid API usage.

This required building local fallbacks for:

  • Mistake explanations
  • Follow-up practice
  • Trap Forge evaluation
  • Daily Practice
  • Demo data
  • Progress summaries

The result is an application whose main educational loop still works when AI is disabled.

Preventing duplicate rewards

Refreshes, browser navigation, multiple tabs, and repeated submissions can accidentally duplicate:

  • XP
  • Achievements
  • Streak updates
  • Follow-up completion
  • Trap Forge rewards

I added deterministic session identifiers and completion checks so important actions are processed only once.

Building a reliable Judge Demo

A hackathon judge may spend only a few minutes testing a project.

The Judge Demo needed to be:

  • Short
  • Deterministic
  • Understandable
  • Resettable
  • Clearly fictional
  • Independent of external services
  • Reliable after refresh
  • Easy to complete on mobile

Supporting mobile and keyboard users

Trapwise contains diagnostics, charts, settings, navigation drawers, forms, leaderboards, achievement cards, and result screens.

Making all of these usable across desktop, mobile, keyboard navigation, and reduced-motion settings required careful focus management and responsive layouts.

Creating accurate visual questions

Visual questions introduced another challenge because the graph, table, diagram, answer choices, and explanation all needed to agree.

Whenever possible, visual questions use structured data so the displayed visual and the solution are based on the same information.

Handling external-service failures

Supabase and OpenAI can fail, time out, or be unavailable.

Trapwise needed to avoid:

  • Infinite loading screens
  • Raw technical errors
  • Lost progress
  • Broken guest mode
  • Duplicate requests
  • Features that appear unusable without external services

This led to local fallbacks, bounded loading states, retry actions, and safer error messages.

Accomplishments that we're proud of

I am especially proud of building an educational system that treats distractors as useful diagnostic information.

Instead of showing only:

Incorrect

Trapwise can explain that an answer pattern may suggest:

  • A wrong operation
  • A solved-wrong-value mistake
  • A graph interpretation issue
  • A confidence mismatch
  • A repeated reasoning shortcut

I am also proud of:

  • Creating the Mistake Twin concept
  • Building a complete guest experience
  • Making the Judge Demo deterministic
  • Keeping the core app functional without an API key
  • Separating mastery, XP, levels, streaks, and pattern strength
  • Building Trap Forge as a reverse-learning activity
  • Adding gradual before-and-after pattern weakening
  • Creating original SAT-style questions
  • Supporting visual questions
  • Building light and dark themes
  • Adding responsive mobile navigation
  • Improving keyboard accessibility
  • Preventing duplicate XP and rewards
  • Creating fictional demo data with privacy safeguards
  • Deploying the application publicly through Vercel

The part I am most proud of is that Trapwise does not just give students another question after they make a mistake. It attempts to train the reasoning pattern that caused the mistake.

You did not just answer another question. You corrected the pattern that caused the original mistake.

What we learned

Building Trapwise taught me that educational feedback becomes more useful when it explains patterns instead of only outcomes.

I also learned that:

  • Wrong answers can contain structured diagnostic evidence
  • Confidence can be as informative as correctness
  • Two students can miss the same question for completely different reasons
  • AI features need deterministic fallbacks
  • Verified content should remain separate from generated feedback
  • Progress systems need protection against duplicate updates
  • Guest mode is important for public demonstrations
  • Accessibility should be designed from the beginning
  • Mobile layouts need to be tested separately from desktop layouts
  • Loading states must always have a failure path
  • Demo data must be clearly separated from real user data
  • Browser refresh and Back navigation can reveal hidden state problems
  • Strong product ideas still need a reliable three-minute demonstration
  • A successful hackathon project needs both technical depth and a clear story

I also gained more experience using:

  • React component architecture
  • Next.js routing
  • TypeScript types and validation
  • Tailwind responsive design
  • Local storage and state recovery
  • Supabase authentication
  • OpenAI API integration
  • Playwright browser testing
  • Accessibility patterns
  • Git and GitHub
  • Vercel deployment
  • Codex-assisted development

What's next for Trapwise

The next stage of Trapwise would focus on expanding the learning system while preserving its local-first reliability.

Future improvements could include:

  • A larger verified question bank
  • More Reading and Writing practice
  • More visual question types
  • Stronger adaptive difficulty selection
  • Longer-term Mistake Twin history
  • Teacher and classroom dashboards
  • Student-created Trap Forge challenges
  • More detailed confidence calibration
  • Improved cross-device synchronization
  • Better offline recovery
  • Additional accessibility testing
  • More complete browser testing
  • Improved multi-tab synchronization
  • Stronger study-plan recommendations
  • Optional weekly learning summaries
  • More advanced GPT-5.6 explanations
  • Question-review and approval tools
  • Community-created original practice content

A future version could also help students compare their current Mistake Twin with earlier versions to see which reasoning patterns have weakened over time.

The long-term goal is to make Trapwise a learning system that does more than count correct answers.

It should help students understand their habits, recognize the traps they repeatedly fall for, and develop strategies for defeating those patterns.

Built with

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS
  • Supabase
  • OpenAI GPT-5.6
  • Codex
  • Playwright
  • Vercel
  • GitHub
  • HTML
  • CSS
  • JavaScript

Try Trapwise

Open the public Trapwise app

Use the Try Judge Demo option to experience the main flow without creating an account.

Disclaimer

Trapwise is an independent SAT-style educational project and is not affiliated with or endorsed by the College Board.

Trapwise Mastery is an internal learning estimate, not an official SAT score.

AI feedback may make mistakes. Verified local answers remain the source of truth.

Built With

Share this project:

Updates