Verse Victory

• 

• 

• 

• 

• 

• 

Inspiration

Most Bible apps help people read Scripture. Verse Victory is built for the harder step: remembering it without looking.

The project began with a simple question: what if Scripture memorization felt like a calm daily ritual instead of a stressful test? Traditional flashcards can feel clinical, while aggressive streaks and leaderboards can distract from the reason someone started. We wanted the learning science of active recall and spaced repetition inside an experience that felt private, encouraging, and spiritually grounded.

What it does

Verse Victory is a native iPhone app for practicing public-domain KJV Scripture in short daily sessions.

A learner chooses verses, then practices as the app progressively hides words. They can tap for a letter, type inline, brush or swipe through a passage, or reveal only the help they need. Review results feed a spaced-repetition scheduler so difficult verses return sooner and familiar verses return less often.

The experience includes:

• Progressive word hiding and active-recall exercises
• A personalized daily review queue
• Word-level hints and adaptive difficulty
• Gentle streaks and progress tracking
• Daily Scripture widgets
• Local reminders using iOS system frameworks
• On-device meaning search
• Bundled public-domain KJV Scripture
• Offline use with no account, tracking, or collected personal data
• Accessibility support for VoiceOver, large text, reduced motion, and alternate interaction paths

Build 47 is entirely free. Scripture and the complete memorization flow are not behind a paywall.

How we built it

Verse Victory is built natively with Swift, SwiftUI, Foundation, WidgetKit, App Intents, AlarmKit, UserNotifications, and App Groups.

The codebase has two reusable layers:

• RitualKit contains the Foundation-only learning engine, including verse models, spaced repetition, streaks, review scheduling, recall logic, and an injectable clock.
• RitualKitUI contains the SwiftUI practice experience, onboarding, widgets, reminders, local storage, accessibility behavior, and the configuration seam that turns the shared engine into Verse Victory.

The app stores Scripture and learning progress locally. App Group storage lets the main app and widget share review state without creating an account or sending data to a server. The recall engine tracks practice history and hint use so the interface can gradually reduce support while keeping the learner in control.

We built the product with Codex powered by GPT-5.6 as an engineering partner. Codex translated product goals into acceptance criteria, implemented and refined Swift and SwiftUI behavior, challenged architecture and launch assumptions, expanded deterministic tests, and repeatedly checked accessibility, privacy, signing, metadata, and physical-device readiness.

What we added during Build Week

Verse Victory existed before the event, so we documented the boundary clearly in the repository README and commit history. The pre-event project already had the basic learning engine, streak logic, local review persistence, and an early onboarding and practice shell. During Build Week we completed a substantial extension:

• Converted build 47 into an honest, entirely free beta and removed misleading purchase routes and paid metadata
• Isolated dormant future StoreKit fixtures from the shipping product and added release guards that prevent commerce claims from returning accidentally
• Rebuilt practice onboarding around behavior-driven lessons, durable lesson state, contextual coaching, replay and reset, and accessibility completion paths
• Added and refined tap-for-letters, inline typing, brushing, swiping, adaptive hiding, card grading, hit testing, scroll-safe gestures, large-text behavior, and VoiceOver alternatives
• Explored voice practice, built transcript and privacy architecture, then deliberately kept live voice out of build 47 until it can meet the offline and reliability standard
• Strengthened local review storage, shared widget state, backup and recovery behavior, reminders, and deterministic on-device search
• Added product-identity guards, privacy alignment checks, metadata validation, simulator isolation, signed-release checks, screenshot export, physical-device verification, and TestFlight handoff documentation
• Expanded unit, integration, UI, accessibility, privacy, and release-gate coverage to 382 passing tests across 41 suites

The repository README links the pre-event baseline, the judged branch, and the full Build Week comparison.

Challenges we faced

Making recall challenging without making it discouraging

If too many words disappear, practice becomes frustrating. If too few disappear, a learner can recognize the verse without recalling it. We combined word-level mastery, review history, adaptive hiding, and user-controlled hints, then refined the touch model so help was available without breaking the flow.

Teaching an unfamiliar interaction

Progressive recall is easy to understand after trying it, but the first session has to teach taps, typing, brushing, grading, and review timing without becoming a tutorial wall. We shifted to small behavior-driven lessons that appear in context and remember what the learner has completed.

Keeping everything private and reliable

Avoiding accounts and cloud storage creates a stronger trust model, but it makes local persistence, recovery, widget sharing, and reminder state critical. We added guarded writes, deterministic tests, relaunch coverage, privacy validation, and release gates around those boundaries.

Knowing when not to ship a feature

Voice recall was promising, and we explored it deeply. The responsible decision was to keep it out of this release until its privacy, offline behavior, and device reliability match the rest of the app. Codex helped turn that judgment into an explicit product policy and a testable release assertion.

Finishing the product, not only the feature

The practice screen was only part of the work. Widgets, App Groups, reminders, accessibility, privacy manifests, signing, screenshots, physical-device behavior, and reviewer instructions all had to form one coherent, reproducible product.

What we learned

Rereading and recalling are very different experiences. A verse can feel familiar while still being difficult to reproduce without prompts. Designing around active recall changed both the interface and the data model.

We also learned that gamification does not have to create pressure. Progress can be visible and motivating without turning a spiritual practice into a competition.

The biggest AI lesson was that the best place for AI was the development workflow, not the learner's private practice. GPT-5.6 and Codex accelerated implementation, critique, testing, and release verification while the shipped app remained fully offline and deterministic.

Finally, a reusable and testable core matters. Separating learning logic from the interface made hard behavior easier to verify and made the product resilient enough for widgets, reminders, accessibility paths, and future learning experiences.

Accomplishments we are proud of

• A complete, coherent iPhone experience rather than a technical prototype
• A private architecture with no account, tracking, runtime AI, or collected learning data
• Nuanced recall interactions that work with scrolling, large text, and assistive technologies
• A transparent Build Week history that distinguishes the existing foundation from the new work
• 382 passing tests across 41 suites
• Release gates covering identity, privacy, metadata, simulator behavior, signed builds, and physical-device verification
• A public demo that shows the real app running and explains how Codex and GPT-5.6 were used

What is next

Next, we want to run a focused TestFlight beta, learn from real memorization sessions, expand curated verse collections, and add richer private progress insights. Voice-based recall remains a future experiment, but it will ship only if it preserves the same offline, private, and dependable standard.

The guiding principle will remain the same: keep Scripture accessible, keep personal practice private, and let technology support the habit without becoming the focus.

Built With

• alarmkit
• app-groups
• app-intents
• foundationdb
• gpt-5.6
• ios
• openai-codex
• spaced-repetition
• swift
• swift-package-manager
• swift-testing
• swiftui
• userdefaults
• usernotifications
• widgetkit
• xcode
• xcodegen
• xctest