What if a swipe left you with something?

The personal moment behind Skrolz

Skrolz began with something I kept noticing in my own family.

My nieces and nephews almost always had a phone nearby. My younger Gen Z brother could move through videos and posts for hours. When I thought about what all that scrolling had left behind, it was often difficult to point to a specific idea, question, or source worth remembering.

But I did not see this as a “young people” problem.

I am a millennial, and I caught myself doing the same thing: opening an app for a moment, falling into an endless feed, and looking up much later without being able to explain what I had gained from the time.

The problem was not that we liked our phones or that swiping was inherently bad. The problem was that most feeds were designed around continuation. Their success depended on whether we kept moving, not whether we understood anything.

I did not want to build a product that lectured people about screen time or told a younger generation to put their phones away.

I wanted to meet people where they already were and ask a different question:

What if every swipe took you deeper into one idea—and the feed ended when you had something worth keeping?

That question became Skrolz.

What Skrolz is

Skrolz is first and foremost a mobile learning app.

It is built with Expo and React Native around the vertical interaction people already understand. For Build Week, judges can experience the Expo learner application immediately in a browser, with no installation, payment, invitation, or permanent account required.

Instead of an endless stream of disconnected facts, Skrolz organizes trusted ideas into finite Knowledge Arcs:

Hook → Prediction → Explanation → Evidence → Counterpoint → Teach-back → Original source → Later memory check

Every Arc has a visible finish line. Each card has one communication goal, and every swipe stays connected to the same central question.

The measure of success is not how long someone remains in the app. It is whether the learner can explain the idea, inspect its evidence, and remember it later.

The Build Week catalog contains six reviewed, source-grounded Arcs:

Why seasons are not about distance
Why the Moon has phases
Why retrieval beats another reread
Why sleep belongs in your study plan
Why cities hold onto the heat
How the greenhouse effect warms Earth

They are presented through three clearly identified Skrolz editorial desks: Space Desk, Learning Lab, and Climate Desk.

The adaptive learning moment

The primary demonstration Arc asks why Earth has seasons.

A learner first makes a prediction. If they choose the common misconception that seasons happen because Earth moves closer to or farther from the Sun, Skrolz does more than mark the answer incorrect.

The response is sent through Firebase App Check to an authenticated Cloud Function. GPT-5.6 compares it with a creator-approved misconception rubric and produces a different explanation grounded only in approved NASA source excerpts.

The result is rendered as a Skrolz learning card—not as a chatbot conversation.

The learner can then open Receipts and inspect the exact source records and reviewed excerpts supporting the explanation.

At the end of the Arc, the learner teaches the idea back in their own words. GPT-5.6 evaluates only creator-approved conceptual coverage. It does not score grammar, accent, personality, or writing elegance.

Skrolz records which concepts were present or missing, updates the learner’s Lore, and lets the learner schedule a later memory check. Notification permission is requested only after the learner chooses when the idea should return.

What has been verified

A documented public-browser rehearsal completed the live adaptive path:

Anonymous Firebase Auth → reCAPTCHA Enterprise App Check → Firebase Cloud Function → GPT-5.6 → Structured Output → deterministic evidence validation → adaptive card

The same learning journey then produced a repaired, validated teach-back result, restored Lore, and persisted a scheduled memory check.

Separate automated tests verify:

The human-approved fallback
Receipts and evidence mapping
Reading-progress resume
Gesture alternatives
Keyboard navigation
Accessibility checks
Light and dark themes
Offline browser recovery
Direct Arc links

If Firebase, App Check, OpenAI, moderation, or a capability flag is unavailable, Skrolz displays a clearly labeled standard explanation. It never presents fallback content as a successful AI result, and fallback evaluations never increase mastery.

The signed Android application also passed physical-device verification for native Google authentication, guest migration, Play Integrity App Check, a protected Firebase callable, and a live source-grounded GPT-5.6 adaptation.

Why GPT-5.6 is necessary

A static quiz can tell someone that an answer is wrong. It cannot reliably understand the misconception behind an open-ended response and choose a genuinely different way to explain the idea.

GPT-5.6 makes the learning path adaptive while staying inside a strict, human-designed boundary.

It receives:

The learner’s response
A creator-approved concept rubric
A creator-approved misconception rubric
Bounded source excerpts
Allowed source and evidence identifiers
Relevant age, language, and depth preferences

It returns a Structured Output that the server validates before anything reaches the learner.

Every factual claim must reference an approved {sourceId, chunkId} pair. Unknown evidence, unsupported claims, malformed responses, refusals, timeouts, quota exhaustion, and unsafe content are rejected.

GPT-5.6 is valuable here because it can recognize how one learner has misunderstood an idea and offer a different route into it. It does not decide what is true, which sources are authorized, or whether generated content can be published.

Trust should be visible

I did not want learners to accept a statement simply because an AI produced it confidently.

Every Arc includes provenance, source records, content versions, AI-involvement information, and human-review metadata.

Opening Receipts maps individual claims to the exact reviewed source material supporting them.

Skrolz recognizes three content origins:

Human Original
Human Curated · AI Adapted
AI Generated from Verified Sources

Generated factual content cannot pass the server’s publication checks without valid evidence and the required human-review state.

Skrolz also avoids presenting its learning evidence as a formal academic grade. Lore shows which key ideas were introduced, developing, or supported by later recall evidence.

The product explicitly describes this as “Skrolz mastery—not a formal academic assessment.”

How I built it

The primary product is an Expo Router and React Native application for mobile, with an Expo web build providing the no-install browser judge experience.

A supporting Next.js site contains the marketing experience and protected Creator Studio and administration surfaces. Privileged creator and moderator accounts are intentionally not distributed to public judges.

The project is a strict TypeScript pnpm and Turborepo workspace.

Firebase provides:

Anonymous authentication
Account linking
Cloud Firestore persistence
Cloud Functions v2
Firebase App Check
Cloud Storage
Remote Config safety switches
Emulator Suite security testing

GPT-5.6 is called only from Firebase Cloud Functions through the OpenAI Responses API.

The integration uses:

Structured Outputs
Versioned prompts and schemas
Explicit reasoning settings
Input and output moderation
Per-user quotas
Idempotency keys
Bounded retries
Hard timeouts
Deterministic evidence validation
Privacy-minimized telemetry
Human-approved fallback content

The OpenAI key never enters the mobile application, browser bundle, GitHub repository, or Vercel environment.

The mobile release

Skrolz is primarily a mobile product. The public browser experience remains the recommended judge path because it requires no installation and has completed the verified live GPT-5.6 journey.

A signed Android preview APK is also publicly available. The current version 0.1.2, build 9 artifact passed checksum, archive, package, manifest, launcher, signing-certificate, native Firebase-module, and embedded release-configuration verification.

It was also installed and exercised on a physical Android 16 device. That verification covered:

Anonymous guest creation
Native Google authentication through Android Credential Manager
Explicit and resumable guest-to-account migration
Permanent-session restoration
Play Integrity App Check
An authenticated Firebase callable
A live, source-grounded GPT-5.6 adaptation
Exact evidence-backed Receipts
Clearly labeled deterministic fallback behavior

Deep-link and offline-recovery behavior have automated browser and configuration coverage, but I do not present them as exhaustive physical-device testing.

Apple sign-in is disabled for this release, and iOS live-AI behavior is not claimed.

How I used Codex

Codex was my primary implementation partner throughout Build Week.

It accelerated:

Product and technical planning
Shared contract design
Expo and Next.js implementation
Firebase Functions and security rules
GPT-5.6 schemas and evidence validators
Automated and adversarial AI tests
Accessibility and responsive visual reviews
Deployment diagnosis
Security auditing
Android release verification
Release and submission documentation

I kept responsibility for the decisions that shaped the product: the problem, target audience, finite Knowledge Arc model, source selection, learning rubrics, privacy boundaries, visual direction, human-review policy, mastery language, fallback behavior, and final release scope.

Codex helped me work across product design, mobile engineering, web engineering, AI architecture, Firebase security, and QA without losing the central idea.

It helped me move faster, but it did not decide what Skrolz should believe.

The hardest challenges

Adapting without becoming a chatbot

The AI needed to influence the learning experience without taking over the interface.

I solved this by having GPT-5.6 return one structured learning card. Skrolz renders that response through the same card system as reviewed content.

Making grounding enforceable

Asking a model to cite sources was not enough.

The backend verifies every source and chunk pair against the immutable Arc version before allowing a generated result to persist or render.

Designing failure as part of the experience

The live path crosses authentication, App Check, Remote Config, Cloud Functions, moderation, OpenAI, schema validation, evidence validation, and Firestore.

Any dependency can fail.

Rather than exposing an internal error or inventing a result, Skrolz continues with reviewed content and clearly tells the learner that it is showing the standard explanation.

Keeping the validator strict

During the first public teach-back test, GPT-5.6 paraphrased a rubric indicator that the deterministic validator required exactly.

The system rejected the output, displayed the fallback, and did not change mastery.

I repaired the prompt to require exact creator-approved indicators, redeployed it, and verified the corrected public teach-back.

That failure was valuable because it demonstrated that the safety boundary was working.

Repairing native authentication

An early Android build sent Google authentication through a browser-style custom URI flow, which Google correctly rejected.

I replaced it with Android Credential Manager and kept Auth, Firestore, Functions, Storage, and App Check inside one React Native Firebase service graph.

The repaired signed APK completed Google authentication, explicit guest migration, Play Integrity App Check, and a live GPT-5.6 learning call on a physical Android device.

Building for mobile while remaining easy to judge

Skrolz is a mobile product, but requiring judges to install an application would create unnecessary friction.

The solution was to make the Expo browser build a real judge experience using the same learner contracts, reviewed content, state machine, and visual language as the mobile application.

What I learned

My biggest lesson was that useful educational AI does not need unlimited authority.

Human reviewers define the question, sources, rubrics, evidence, and publication decision. Deterministic code enforces the factual boundary.

Inside that boundary, GPT-5.6 can do something valuable that static content cannot: recognize how one learner misunderstood an idea and offer a better way into it.

I also learned that the opposite of endless scrolling is not necessarily avoiding the phone.

It can be designing a better ending.

A session can be short, tactile, and familiar while still respecting a person’s attention and leaving them with an idea they can explain.

What is working now

The verified public experience includes:

A mobile-first Expo and React Native application
A no-install browser build of the learner app
Anonymous guest access
Six reviewed, source-grounded Knowledge Arcs
One verified evidence-valid public-browser GPT-5.6 adaptation
One verified repaired teach-back evaluation
Exact claim-to-source Receipts
Lore restoration and memory-check scheduling
Tested reading-progress recovery
Tested gesture and keyboard alternatives
Tested deterministic fallback behavior
A signed Android preview with physically verified Google authentication, Play Integrity App Check, and live GPT-5.6 adaptation
A public, MIT-licensed repository with setup, testing, security, architecture, and release documentation

Prior-work disclosure

I published an earlier Skrolz concept in February 2026.

This Build Week entry is a new Expo, Next.js, Firebase, and OpenAI implementation created during the event. No source code from the earlier project appears in this repository’s Git history.

The name and broad educational-feed idea continued, but the product architecture, adaptive workflow, evidence system, mobile experience, backend, tests, and release implementation are new.

What comes next

I want to expand the reviewed catalog and study how well Skrolz’s learning evidence corresponds with delayed recall over longer periods.

Future work could include educator-authored pathways, multilingual Arcs, broader physical-device accessibility testing, carefully designed voice teach-back, and deeper relationships between concepts in Lore.

But the principle will remain simple:

Your feed should leave you with something.

Skrolz. One swipe deeper.