Faultline

Inspiration

AI answers are often judged by how fluent they sound.

That is the problem.

A response can be polished, confident, detailed, and still contain one sentence that quietly breaks the reasoning. Students are constantly told to “verify AI output,” but that advice is too vague to become a practical skill. Verification has to be practised.

Faultline began with one question:

What if learning to evaluate AI felt more like a game than a warning label?

Instead of asking learners to memorise another fact, Faultline asks them to inspect an answer, find the exact point where it becomes unreliable, diagnose the reasoning failure, and decide how the claim should be verified.

The goal is not to teach students to distrust AI. It is to help them develop calibrated trust.

What it does

Faultline is a colorful daily reasoning game built around a simple challenge:

Two answers. One hidden flaw. Find the crack.

Each round presents a question and two convincing answers. One is reliable. The other contains a subtle but meaningful fault.

The player must:

Choose the unreliable answer.
Identify the exact sentence where the reasoning fails.
Diagnose the type of fault.
Choose the best way to verify the claim.

Fault categories include:

Wrong cause
Missing context
Misleading statistics
Unsupported conclusions
Citation mismatch
Outdated information
Hidden assumptions
Edge-case failures

Players earn scores, XP, levels, streaks, and mastery across different reasoning categories. Their progress is represented through a collectible Fault Deck, which shows the mistakes they recognise well and the ones they still need to practise.

Faultline also includes a Creator Lab where educators and learners can build their own challenges, validate them, play them through the complete game flow, save drafts locally, and export them as JSON.

How we built it

Faultline was built using:

JavaScript
Node.js
Browser local storage
Node’s built-in test runner

The application is separated into modules for:

Curated challenge content
Gameplay rendering
Scoring
XP and replay rules
Progress persistence
Creator Lab validation
Static serving and security

The challenge system was designed around a strict rule: every challenge must contain exactly one intended fault and one clearly addressable faulty sentence.

How we used GPT-5.6 and Codex

GPT-5.6 was involved throughout the creation of Faultline.

We used GPT-5.6 in ChatGPT to help develop the original concept, refine the daily-game loop, define the fault categories, shape the scoring and mastery systems, structure the curated challenges, plan Creator Lab, create the visual direction, generate and refine the initial implementation, and prepare the supporting project documentation.

Once the working application was complete, we opened the repository in Codex using GPT-5.6 Sol for a substantive final engineering pass.

Codex inspected the complete codebase, ran the existing test suite, and audited:

Gameplay flows
Scoring calculations
XP and replay behaviour
Daily-completion logic
Browser-storage handling
Challenge validation
Creator Lab safety
Keyboard navigation
Screen-reader behaviour
Responsive layouts
Static-server security
Documentation accuracy

That review identified several issues that were difficult to notice during ordinary gameplay, including:

A fast player could still receive a clean-round bonus after making a mistake.
Replaying a challenge could incorrectly award additional XP.
Daily reward enforcement depended too heavily on bounded result history.
Malformed browser storage could break parts of the experience.
Keyboard focus could disappear after interface rerenders.
Some challenge sources were too broad for the claims they supported.

Codex then implemented the approved fixes, strengthened validation, improved accessibility and responsive behaviour, expanded the automated suite from 12 to 18 passing tests, and reviewed the final changes for regressions.

We remained responsible for the core product decisions, reviewed Codex’s implementation plan, approved the scope, reran the tests independently, and requested an additional review before merging the final changes.

Challenges we ran into

Measuring reasoning instead of guessing

A normal two-answer quiz would have been easier to build, but it would not prove that the learner understood why an answer was unreliable.

Faultline therefore requires the player to identify the exact sentence where the reasoning breaks.

A player can choose the correct answer card and still be wrong about the actual fault.

Creating believable flawed answers

The unreliable answer had to be convincing enough to require inspection, while still containing one clearly intended mistake.

If the fault was too obvious, the game was not challenging. If several sentences were debatable, the scoring felt unfair.

Designing fair scoring

We wanted to distinguish between:

Guessing the unreliable answer
Locating the precise fault
Diagnosing the error correctly
Choosing an effective verification method
Completing a clean round without clues or mistakes

This required separate scoring stages, clue penalties, mistake penalties, speed bonuses, XP caps, replay protection, and clear result breakdowns.

Preserving progress safely

Progress is stored in the browser, so we had to handle:

Unavailable storage
Full storage
Malformed saved data
Legacy progress formats
Same-day replays
Bounded result history
Daily XP limits

One edge case discovered during the Codex review involved daily reward evidence being removed after enough historical rounds. We solved this by creating a separate dated reward ledger and added tests covering same-day replay, history eviction, next-day rewards, and malformed legacy progress.

Accessibility after rerenders

Faultline replaces major sections of the interface as the player moves through each phase.

That initially caused keyboard focus to disappear. We added deliberate focus restoration, live announcements, visible focus states, semantic progress indicators, selected-state attributes, and reduced-motion support.

Making education feel like a game

Faultline teaches a serious skill, but it could not feel like another school portal.

We used bold colors, thick outlines, animated cracks, collectible cards, XP, streaks, and playful feedback to make the experience feel more like a daily puzzle than an assessment platform.

Accomplishments that we're proud of

We are proud that Faultline is more than a “spot the wrong answer” quiz.

The player must demonstrate four separate abilities:

Suspicion
Precision
Diagnosis
Verification

The strongest interaction happens when a player chooses the unreliable answer but highlights the wrong sentence.

Faultline responds:

You found the suspicious answer, but not the fault.

That moment captures the purpose of the entire project.

We are also proud of:

The exact faulty-sentence mechanic
The animated crack reveal
The Fault Deck mastery system
The local Creator Lab
Deterministic scoring
Same-day replay protection
Safe progress migration
Keyboard and screen-reader support
Responsive mobile and tablet layouts
Eighteen passing automated tests
A complete playable experience that requires no account setup
A final Codex review that found no discrete correctness regression in the changed code

Most importantly, GPT-5.6 and Codex contributed to both the creation and technical quality of the product rather than being added as a superficial feature.

What we learned

We learned that AI literacy is not one skill.

It includes:

Separating confidence from evidence
Recognising unsupported claims
Checking causal explanations
Inspecting numbers and sample sizes
Looking for missing context
Testing edge cases
Verifying sources
Knowing when certainty is unjustified

We also learned that educational games should reward the reasoning process, not only the final answer.

From an engineering perspective, we learned how useful GPT-5.6 can be when used across the full product lifecycle.

During creation, it helped us move from an abstract idea to a working product with a clear game loop, visual identity, challenge format, scoring system, and Creator Lab.

Through Codex, GPT-5.6 Sol was especially valuable when reasoning across different parts of the repository:

Connecting scoring rules to interface claims
Connecting replay logic to result-history limits
Connecting storage failures to broken gameplay
Connecting accessibility semantics to rerender behaviour
Connecting educational claims to source quality
Connecting documentation to the actual implementation

We also learned the importance of reviewing AI-generated work. Codex proposed and implemented changes, but we inspected the plan, controlled the scope, tested the result independently, and requested a second review that uncovered one additional XP-history edge case before submission.