Case study
Actually Learn
A local-first iPhone app that turns course material into guided, interactive practice.
Problem
Removing the work around learning
Most learning tools still ask the learner to decide what to study, how to practice it, and whether they understood it. I wanted to see whether structured course material could instead become an obvious sequence of small actions, with immediate feedback and room to explore when a learner wanted more context.
The difficult part was providing enough direction to remove that setup work without reducing a conceptual subject to flashcards or passive reading. The app needed to guide progression, require active reasoning, and preserve the learner's notes and history while remaining useful offline.
Product evolution
Each version removed a different source of friction
Actually Learn began as a local-first retrieval and spaced-practice app. Testing exposed deeper problems: review history could survive while a skill still appeared unseen, a learning session could contain no prompts, and a supposedly different challenge could test the same kind of reasoning with different words.
I first added explicit prerequisites, multidimensional mastery, and dependency-aware review. The larger change came later, when I realized that a detailed skill graph still asked the learner to interpret the system before doing any work; the primary experience therefore shifted from a collection of cards to one guided path with a clear current lesson.
- Retrieval practiceImported notes, spaced review, and local evidence
- Prerequisite skill systemDependencies, weaknesses, and adaptive review
- Guided mastery pathOne clear lesson and immediate interactive practice
Product model
Keep progression linear and exploration optional
The path answers “What should I do next?” by opening directly into an exercise and feeding the result into later review. Explore answers a different question: “Why does this work?” It can branch from feedback, use local reference material or optional AI assistance, and then return the learner to the exact exercise state without awarding mastery for reading.
- Mastery pathOne current lesson
- Interactive exerciseActive reasoning
- Immediate feedbackAnswer and explanation
- EvidencePerformance and confidence stored separately
- Adaptive reviewExplainable next practice
Product walkthrough
Move from one clear lesson into targeted review
The path keeps the next lesson visible, while each response produces feedback the learner can explore without losing their place. Those results then become inputs to an adaptive review session that states why each exercise was selected.
01The path identifies one current lesson while preserving progress. 
02A lesson opens directly into a short active exercise. 
03Deterministic grading returns the result and reasoning immediately. 
04Explore adds context without changing the learner's score or place. 
05Review explains whether each prompt repairs or refreshes a skill. 
06Mixed practice asks the learner to select and apply the right model.
Interaction design
Make the learner assemble the relationship
A formula can be recognized without being understood. In construction exercises, the learner builds an expression from its parts before the app evaluates the order and explains the relationship. This provides stronger evidence than selecting a familiar-looking formula from a list while keeping the interaction short enough to use inside a lesson.
01Build the expression one component at a time. 
02Review the complete relationship before submitting it. 
03Confirm the answer and connect it back to the underlying idea.
Key decisions
Product choices and their costs
Guided path by default
The learner always has a clear next action, although the primary flow offers less freedom than a dashboard of study options.
Ten reusable exercise types
Different concepts can require matching, construction, calculation, prediction, diagnosis, or explanation, but the content model has to support all of those interactions consistently.
Deterministic grading first
Objective exercises work offline and produce explainable results; free-response feedback remains advisory rather than silently changing mastery.
Performance and confidence stay separate
“Was the answer correct?” and “How did this feel?” are both useful, but confidence never overwrites demonstrated performance.
Local persistence as the baseline
Lessons, attempts, and review history remain available without an account, network connection, cloud entitlement, or paid AI service.
AI stays behind a capability boundary
Apple Intelligence can vary a challenge or respond to reasoning, but it cannot determine objective mastery or interrupt a study session when unavailable.
Vertical slice
Using WACC to test the full learning loop
I chose weighted average cost of capital as the first high-fidelity lesson because it could test more than formula recall. A learner might know how to calculate WACC without understanding its inputs, predicting how it changes, or recognizing when another discount rate is more appropriate.
- Match debt and equity investors with their required returns.
- Construct the WACC formula from tactile tokens.
- Calculate a simple WACC numerically.
- Predict the effect of a higher cost of equity.
- Diagnose the use of book-value weights.
- Choose the appropriate rate for equity-only cash flows.
- Report confidence without changing the objective score.
Building one lesson across all of those actions forced the content model, renderer, grading engine, persistence layer, and review logic to work together before I expanded the rest of the Finance path.
System design
Separate content, interaction, grading, and evidence
Content describes what the learner should reason about, while the renderer controls how the exercise behaves, the engine grades the response, SwiftData records the evidence, and the adaptive layer decides what should appear again. Keeping those responsibilities separate allows the same mechanics to support Finance now and other subjects later.
- Course contentLessons and exercise definitions
- Exercise rendererTen reusable interactions
- Grading engineDeterministic evaluation
- SwiftData storeAttempts, confidence, and progress
- Adaptive reviewNext practice from stored evidence
AI-assisted development
Use AI for implementation support, not product judgment
I used AI coding agents during implementation while retaining ownership of the product model, architecture boundaries, sequencing, acceptance criteria, and validation. That distinction mattered because a plausible implementation could still violate a core rule, such as allowing a confidence rating to change mastery or losing an unfinished session after relaunch.
I applied the same boundary inside the product. Apple Intelligence can generate a grounded variation, identify a missing idea, or offer a Socratic follow-up, but deterministic evidence continues to control correctness, mastery, and scheduling. If AI is unavailable, the core learning loop still works.
Validation
What the prototype establishes
- Course content
- 18 Finance lessons
- Interaction model
- 10 exercise types
- Validation
- 67 automated tests
Verified
- All ten exercise types have grading coverage.
- Incorrect answers reveal the answer and an explanation.
- Explore restores the exact lesson state when closed.
- Unfinished sessions survive relaunch.
- Confidence does not alter correctness.
- Existing imports and review history remain intact.
Not yet established
- Long-term learning or retention outcomes with real learners
- Production-scale content authoring across multiple subjects
- Physical-device haptic quality across supported iPhones
- TestFlight or App Store distribution
Next questions
Test whether the structure actually helps
The architecture can produce and preserve a complete learning loop; the next risk is whether learners experience that path as useful rather than merely structured. I would next observe several learners completing the same lesson, measure starts, completions, retries, and Explore usage, and test whether mixed cognitive formats improve delayed retrieval before expanding content breadth.
Working prototype
Try Actually Learn
The Appetize preview runs the iPhone build in a browser. Free sessions are limited to three minutes, so it is best used as a short walkthrough of the mastery path and one lesson.