Future Paths: Learning Path Simulator

An open learning simulator built entirely through natural-language direction—and released with source files and prompts so non-programmers can adapt and continue it with AI.

Comment

Inspiration

Future Paths began as a private tool for one learner in one family.

I wanted to understand not only where my child was in a learning program, but how different study plans might change the months ahead. A single progress number showed the present, but it did not help us explore possible futures.

I wanted to ask:

  • What happens if the current weekly plan continues?
  • What changes if the workload becomes slightly lighter or stronger?
  • How far might the learner progress before a target date?
  • Which goals appear reachable under each plan?
  • What assumptions are shaping the forecast?

Most progress trackers describe the past or present. I wanted a tool that could make several possible futures visible and discussable.

I am a freelance writer and photographer, not a professional software developer. I did not directly edit a single character of the application’s HTML, CSS, or JavaScript.

Instead, I described the real-life problem, the behavior I wanted, the privacy boundaries, and the decisions that mattered in natural language. GPT-5.6 helped turn those ideas into structured implementation prompts. Codex generated and revised the project files.

As the application developed, I realized that the simulator itself was only one part of the project.

The larger experiment was whether a non-programmer could use lived experience, editorial judgment, testing, and natural-language direction to create working software—and then release both the result and a practical way for other people to continue it.

Future Paths therefore became two things at once:

  1. a working learning-path simulator;
  2. a concrete demonstration of software created, reviewed, distributed, and inherited through natural language.

The application is the evidence. The real project is the method.

What it does

Future Paths is a bilingual, browser-only learning-path simulator.

It turns dated progress records into visual forecasts across Japanese, Math, and English.

The public prototype can:

  • track current worksheet positions across three subjects;
  • calculate an Observed Pace Baseline from anonymized progress history;
  • adjust the weekly worksheet total for each subject;
  • compare Lighter, Current, and Accelerated plans;
  • project future worksheet positions toward a selected target date;
  • compare projected progress with learning benchmarks used in Japan;
  • show how much of the remaining distance toward a selected goal may be completed;
  • visualize anonymized progress history;
  • import updated progress records from CSV;
  • switch between English and Japanese; and
  • store settings locally in the browser.

The forecast does not treat every completed worksheet as an equal amount of new progress. Real learning includes repetition, review, difficult material, pauses, missed days, and temporary acceleration.

The public model therefore begins with the learner’s observed historical pace and scales it according to the selected weekly worksheet plan. It does not add a manual ability boost or an optimistic award-oriented adjustment.

The displayed goal-completion percentage is not a probability of receiving an award. It shows how much of the remaining worksheet distance is projected to be completed by the target date.

Future Paths is intended as a planning and conversation tool, not as a certain prediction of a child’s future.

All calculations, CSV processing, and settings storage run locally in the browser. No account, backend, or server-side data transmission is required.

Future Paths is also distributed as an AI-editable software artifact.

The public project includes:

  • the complete source files;
  • a downloadable source ZIP;
  • a copyable starter prompt;
  • a bilingual AI customization guide;
  • documentation of the development process;
  • privacy guidance; and
  • an MIT License.

A non-programmer can download the files, ask an AI assistant to explain the project, describe a different curriculum or workflow, generate a new implementation prompt, and use Codex or another coding agent to create a customized version.

How we built it

I did not directly edit the application code.

The entire development process was directed through natural language.

My role was to contribute:

  • the lived experience behind the problem;
  • the purpose of the product;
  • the requirements and constraints;
  • the privacy boundaries;
  • the design decisions;
  • the testing;
  • the editorial judgment; and
  • the final responsibility for what the software should become.

GPT-5.6 helped me turn lived experience, product decisions, privacy requirements, and review feedback into detailed implementation prompts.

Codex generated and revised every project file, including the HTML, CSS, JavaScript, bilingual interface, forecasting behavior, CSV support, local-storage handling, public documentation, and distribution materials.

The workflow was iterative:

  1. I described what I needed or what felt wrong.
  2. GPT-5.6 helped clarify the problem and turn it into an implementation prompt.
  3. Codex generated or revised the files.
  4. I used the resulting application and evaluated its behavior.
  5. The files were brought back into ChatGPT for structural, conceptual, privacy, and presentation review.
  6. Claude or Gemini were sometimes used for additional perspectives.
  7. I compared the feedback rather than accepting it automatically.
  8. GPT-5.6 helped synthesize the useful findings into the next Codex prompt.
  9. The loop continued until the public version matched the intended purpose.

For OpenAI Build Week, I transformed the original family-specific prototype into a public, privacy-safe, bilingual, and reusable project.

The public version:

  • removes names and identifying details;
  • alters or removes exact dates;
  • separates the private original from the public repository;
  • uses an anonymized real-world sample;
  • explains the assumptions behind the forecast;
  • adds an English-first bilingual interface;
  • provides source-download and customization pathways; and
  • documents how another non-programmer can continue the software with AI.

This process was editorial rather than syntactic.

I did not manipulate the code directly, but I remained responsible for what the software should do, what it should communicate, what it should not expose, and when it was ready.

Challenges we ran into

Representing learning progress without pretending it is linear

Real learning progress includes repetition, review, missed days, changing difficulty, pauses, acceleration, and decisions made by the learner or instructor.

A forecast based only on elapsed days or completed worksheet counts could create misleading certainty.

I therefore had to separate:

  • recorded worksheet positions;
  • elapsed time;
  • observed historical progress;
  • the selected weekly workload;
  • the target date;
  • the target worksheet position; and
  • alternative study-plan scenarios.

The current model uses anonymized progress history to calculate an Observed Pace Baseline, then scales that baseline according to each weekly plan.

Avoiding double correction

The observed history already contains the effects of repetition, difficult material, missed days, and normal variation.

Applying an additional general difficulty discount would reduce the forecast twice. Adding an ability bonus or an award-oriented acceleration would create a different form of distortion.

The public version therefore extends the observed pace without adding those manual corrections.

Making estimates understandable without making them look authoritative

A numerical forecast can appear more certain than it really is.

The interface emphasizes assumptions, alternative paths, and projected positions rather than presenting one future as fact.

The goal-completion percentage is explicitly described as progress across the remaining worksheet distance, not a statistical probability or an official award decision.

Protecting a real learner’s privacy

The original prototype contained private family records, exact dates, individual goals, and personal labels.

The public version had to retain the useful structure of the real experience without exposing the identity or exact history of a child.

Names, identifying details, and exact dates were removed or altered. Public project files were kept separate from private data, screenshots, and the original family version.

Translating dissatisfaction into implementable instructions

Because I was not directly editing the code, saying “this feels wrong” was not enough.

Each problem had to be converted into a clear decision:

  • what behavior was incorrect;
  • why it was incorrect;
  • what should remain unchanged;
  • what the new behavior should be;
  • how it should be tested; and
  • what private information must never enter the public version.

This made prompt design part of the software-development process.

Explaining what the project actually is

The application itself is intentionally modest.

The hardest editorial challenge was explaining that the central contribution is not only the learning simulator, but the repeatable method used to create, review, distribute, and continue it.

The project had to demonstrate the idea without overstating it.

Future Paths does not claim to define the future of software development. It offers one concrete, working example of what is now possible.

Accomplishments that we're proud of

I am proud that a private family question became complete, working, public software.

Without directly editing the code, I was able to direct the creation of an interactive application that combines:

  • anonymized progress records;
  • three subjects;
  • weekly workload controls;
  • curriculum-level transitions;
  • multiple future scenarios;
  • target dates;
  • benchmark comparisons;
  • bilingual presentation;
  • CSV import; and
  • local browser storage.

I am also proud that the application avoids presenting one projected future as the answer.

Users can change the assumptions and immediately see how the possible paths change.

The public version is not only privacy-safe and usable. It is also designed to be inherited.

It includes:

  • public source files;
  • a source ZIP;
  • starter prompts;
  • a customization guide;
  • development documentation;
  • privacy boundaries; and
  • an open license.

The most meaningful accomplishment is therefore not simply that a non-programmer directed AI to create software.

It is that the resulting software was packaged so that another non-programmer can understand it with AI, describe new needs in natural language, and continue developing it.

What we learned

The most important thing I learned is that software authorship is not identical to typing code.

A person can contribute the lived experience, purpose, structure, constraints, testing, judgment, and final responsibility while an AI system performs the syntactic implementation.

That does not eliminate the need for human skill. It changes which human skills become central.

The most important abilities in this project were:

  • noticing a real problem;
  • describing an experience accurately;
  • separating facts from assumptions;
  • deciding what the product should mean;
  • preserving privacy;
  • evaluating outputs critically;
  • recognizing when something worked technically but failed conceptually;
  • comparing conflicting AI recommendations; and
  • knowing what to keep, revise, or remove.

Those are editorial skills.

I began the project as a writer using AI to make a tool. I finished it understanding that editing can extend beyond text.

An editor can identify the material, shape the structure, direct multiple contributors, evaluate each result, protect the intended meaning, and decide when the work is complete.

In this project, some of those contributors were AI systems, and the final medium was software.

Natural language became a bridge between lived experience and an executable system.

An essay asks a reader to understand an idea. A program lets a person act inside it.

Future Paths is my first attempt at an executable essay: a personal idea transformed into a working system that another person can explore, question, and adapt.

I also learned that open source can mean more than making code visible.

For many non-programmers, source files alone are not practically reusable. They may also need:

  • a prompt that helps an AI explain the files;
  • guidance about what can safely be changed;
  • instructions for generating an implementation prompt;
  • privacy warnings;
  • testing expectations; and
  • a clear license.

The software becomes more meaningfully inheritable when both the artifact and the path for continuing it are open.

Open by design

Future Paths was not created primarily for exclusive ownership or monetization.

The source files are released under the MIT License so that anyone can use, copy, modify, redistribute, sell, and build upon them, provided that the original copyright notice and license text are preserved.

I want the original attribution to remain so that people can identify who started the project. That attribution is not intended to prevent other people from using, modifying, redistributing, or extending the software under the MIT License.

The value of Future Paths is not limited to one finished application.

A small tool born from one person’s lived experience can be inherited by others, adapted to different needs, improved, and passed on again.

For this project, “open” does not only mean that the source code can be viewed.

It means that the ability to continue developing the software is open to others.

The application is open source. More importantly, the ability to continue creating it is open.

The MIT License permits use, modification, redistribution, inclusion in other projects, and commercial use. Modified versions do not have to be published or contributed back, but the original copyright notice and license text must be preserved.

The MIT License applies to the original Future Paths source code and documentation. It does not grant rights to third-party trademarks, logos, curriculum materials, benchmark publications, or copyrighted content.

What's next for Future Paths: Learning Path Simulator

The next step is to see whether other people can successfully inherit and adapt the project.

Possible improvements include:

  • a guided setup process for defining subjects, goals, and schedules;
  • clearer explanations of every forecasting assumption;
  • automated tests for worksheet-level transitions and projections;
  • optional user-defined planning anchors;
  • easier import and export of progress data;
  • reusable curriculum and benchmark configurations;
  • improved accessibility and mobile usability;
  • additional visual comparisons between possible paths;
  • examples for curriculum structures outside the original context;
  • documentation of community-created variations; and
  • reports on successful and unsuccessful AI-assisted customizations.

The long-term goal is not to create one universal forecast for every learner.

It is to provide an open starting point that families and other users can reshape around their own circumstances.

Future Paths will remain available under the MIT License so that other people can use, modify, redistribute, and build upon it while preserving the original attribution and license text.

Privacy and independence

The public sample is derived from a real learner’s progress, but names, identifying details, and exact dates have been removed or altered.

The public repository does not contain the private original application, personal learner records, private screenshots, exact family history, or identifying local data.

All application calculations and CSV processing occur locally in the browser. Settings and imported records are stored in local browser storage. No login or server-side data transmission is required.

Users who load their own files, CSV records, or screenshots into third-party AI services should first review those services’ storage, retention, sharing, and training terms.

Future Paths is an independent project inspired by a real family’s use of Kumon in Japan.

It is not affiliated with or endorsed by Kumon. It does not replace an Instructor’s individualized lesson plan, provide an official Kumon forecast, or calculate official award eligibility.

The names of learning benchmarks are used only to explain the original Japanese planning context.

Built With

  • ai-assisted-development
  • bilingual
  • browser-only
  • chatgpt
  • codex
  • css3
  • csv
  • github
  • gpt-5.6
  • html5
  • javascript
  • localstorage
  • mit-license
  • natural-language
  • open-source
  • openai
  • privacy-first
  • svg
  • vanilla-javascript
Share this project:

Updates