How to turn a new subject into a learning roadmap with Super Intelligence begins by resisting the urge to collect everything. A new subject looks large because the learner cannot yet distinguish foundations from extensions, prerequisites from applications, central concepts from vocabulary and real milestones from interesting side paths.
SI can create a roadmap quickly, but speed is useful only if the roadmap reflects the learner’s actual goal, starting state and evidence of progress.
In the eduKateSG life series, Super Intelligence, or SI, is our editorial name for practical AI assistance. This article follows How to Ask Super Intelligence to Explain Difficult Ideas at Different Levels and turns explanation into a longer learning architecture.
The central rule is: a learning roadmap is not a table of contents. It is a sequence of capabilities with prerequisites, evidence gates and outputs.
Start with the Destination
Before asking what to study, define what the learner wants to be able to do.
“Learn economics” is too broad.
“Understand introductory microeconomics well enough to analyse basic market scenarios and read an undergraduate text” is more useful.
“Learn Python” is broad.
“Write, test and debug small Python programs that process files and data” defines an output.
“Improve English” is broad.
“Write clear Secondary-level argumentative essays with strong vocabulary and evidence” creates a roadmap target.
Ask SI to turn the aspiration into observable independent outputs.
The Roadmap Spine
Use eight layers: Outcome → Scope → Prerequisites → Core Concepts → Skill Corridors → Milestones → Projects → Transfer Gates.
Outcome
What independent capability proves the learning matters?
Scope
What belongs in this roadmap and what is intentionally excluded for now?
Prerequisites
What prior knowledge is assumed?
Core concepts
Which ideas organise the subject?
Skill corridors
Which sequences of knowledge and procedures must become stable?
Milestones
What intermediate outputs show progress?
Projects
Where does the learner integrate skills into meaningful work?
Transfer gates
What changed or realistic task proves independence?
Scope Before Content
New subjects expand easily.
A learner asks about data analysis and quickly encounters statistics, programming, databases, visualisation, machine learning and domain knowledge.
Not all of that belongs in the first roadmap.
Ask SI to create three boundaries:
- core now;
- useful later;
- out of scope for the current goal.
This prevents the roadmap from becoming an encyclopedia.
The Scope Test
Every topic should answer one question: “Which target capability does this enable?”
If the connection is weak, move it to later.
Interesting content is not automatically roadmap content.
Prerequisite Mapping
A roadmap should begin with assumed prerequisites and a diagnostic, not a declaration that the learner is a beginner.
For calculus, prerequisites may include algebraic manipulation, functions and graphs.
For coding, prerequisites may include basic computer file use and logical sequencing.
For academic writing, prerequisites may include sentence control, reading comprehension and paragraph structure.
Ask SI to create one small diagnostic for each prerequisite and remove stable prerequisites from the active plan.
Prerequisite Debt
If the learner skips a weak prerequisite, the debt appears later as slow progress, repeated errors and fragile understanding.
The roadmap should record prerequisite debt explicitly rather than pretending every learner can start at the same chapter.
Repair the debt when it blocks multiple downstream skills.
Core Concepts Versus Topics
Topics organise a syllabus. Concepts organise understanding.
In economics, scarcity, incentives, marginal thinking and equilibrium connect many topics.
In biology, structure-function, energy, information and regulation connect many chapters.
In programming, state, abstraction, control flow, data structures and interfaces connect many tools.
Ask SI to identify the concepts that reappear across the subject.
These concepts deserve deeper explanation because they compress the field.
Concept Anchors
For each core concept, attach one definition, one mechanism, one example, one contrast and one transfer question.
This creates stable anchors that later topics can reference.
Skill Corridors
A skill corridor is a dependency path from prerequisite to independent output.
Example, academic writing: claim → evidence selection → explanation → paragraph coherence → multi-paragraph argument → timed essay.
Example, Python: variables → conditionals → loops → functions → files/data → testing/debugging → small application.
Example, algebra: number control → expansion → equations → simultaneous equations → applications.
Roadmaps become actionable when topics are converted into corridors.
Parallel Corridors
Some skills can develop in parallel.
Language learning can build listening and vocabulary retrieval together.
Coding can build syntax and debugging together.
Science can build content knowledge and explanation-writing together.
Ask SI which corridors share prerequisites and which can progress independently.
Milestones Need Outputs
“Finish Chapter 3” is an activity milestone.
“Solve ten changed linear-equation questions without hints” is a capability milestone.
“Watch the database tutorial” is an activity.
“Design and query a small relational database with two linked tables” is an output.
Use outputs wherever possible.
Milestone Gates
Each milestone should have an entry condition and exit test.
Entry: prerequisites stable enough to begin.
Work: explanation and practice.
Exit: independent output or transfer task.
Fallback: which prerequisite to revisit if exit fails.
This turns the roadmap into a control system rather than a calendar.
Projects Integrate the Roadmap
Projects reveal whether separate skills can work together.
A coding roadmap might build a text-processing tool.
A data roadmap might analyse a small dataset and communicate findings.
A writing roadmap might produce an evidence-based article.
A language roadmap might prepare and deliver a short presentation.
A Mathematics roadmap might culminate in mixed multi-topic problem sets rather than a creative project.
The project should resemble the real output the learner cares about.
Project Timing
Do not wait until the end for every project.
Use small projects after major corridors so integration problems appear early.
SI can scale the project difficulty as more capabilities become available.
Worked Roadmap: Introductory Python
Outcome: write and debug small Python programs that process files and data.
Scope now: syntax, variables, conditionals, loops, functions, collections, files, errors, testing basics.
Later: web frameworks, advanced object-oriented design, machine learning.
Prerequisite diagnostic: file paths, basic computer use, logical sequencing.
Corridor 1: variables → expressions → input/output.
Corridor 2: conditions → loops.
Corridor 3: functions → decomposition.
Corridor 4: lists/dictionaries → data processing.
Corridor 5: files → error handling → small project.
Milestones use programs written from requirements, not tutorial completion.
Final transfer: build a small program from a new specification without copying a previous solution.
Worked Roadmap: Secondary Mathematics Repair
Outcome: regain independent performance across current school Mathematics.
Baseline identifies stable arithmetic, unstable algebra expansion and slow word-problem method selection.
Scope prioritises algebra and current school dependencies before optional enrichment.
Corridor A: signs → expansion → simplification → equations.
Corridor B: relationship identification → method selection → multi-step word problems.
Milestones: changed untimed tasks, mixed tasks, then timed transfer.
Roadmap review occurs weekly because school topics continue moving.
Worked Roadmap: Academic Writing
Outcome: produce clear evidence-based essays independently.
Prerequisites: sentence control, comprehension and basic paragraphing.
Core concepts: claim, evidence, reasoning, structure, audience and revision.
Corridor 1: topic sentence → claim.
Corridor 2: evidence selection → explanation.
Corridor 3: paragraph sequence → thesis.
Corridor 4: counterargument → qualification.
Projects: short response, multi-paragraph essay, timed essay.
Roadmap Pacing
Do not convert every milestone into a fixed date before testing the learner.
Use a pacing range and update from evidence.
Fast progress on stable prerequisites should compress the schedule. Repeated transfer failure should slow the roadmap and repair the corridor.
The roadmap serves learning, not the other way around.
Weekly Load
Define sustainable weekly capacity first.
A brilliant roadmap requiring ten hours is irrelevant if the learner has four.
Ask SI to produce a minimum viable weekly plan and an optional extension.
Protect recovery and existing commitments.
Roadmap Sources
Every roadmap should identify the core sources.
Primary textbook or course.
Official documentation or syllabus.
Practice source.
Reference source.
SI-generated explanations and tasks sit around those sources rather than replacing the source structure where alignment matters.
Source Overload
Do not assign five textbooks and twenty channels because SI can find them.
Use one primary path plus selective supplements for gaps.
A roadmap with too many sources creates navigation work instead of learning.
The Roadmap Review
Every roadmap needs a regular review loop.
What milestone passed?
What corridor is blocked?
Which prerequisite drifted?
Which source is not helping?
Which activity can be removed?
Which new school, work or life deadline changes priority?
SI can update the roadmap from the review without rebuilding the entire plan.
Version the Roadmap
Use simple versions when material changes occur.
v1 baseline roadmap.
v2 after prerequisite diagnostic.
v3 after first project reveals a transfer gap.
The version history explains why the sequence changed.
A Copyable Learning Roadmap Prompt
“Turn this subject into a learning roadmap for my actual goal. First define the independent output that would prove useful competence. Set the scope: core now, useful later, out of scope. Map prerequisites and give me short diagnostics rather than assuming my level. Identify core concepts that recur across the subject. Convert topics into skill corridors with dependencies. For each milestone, define entry condition, learning work, exit test and fallback. Add small integration projects or mixed tasks. Use my sustainable weekly capacity. Include primary sources, review cycles, transfer gates and conditions for changing the roadmap.”
Roadmap Failure Modes
Table-of-contents roadmap
Lists chapters but not capabilities. Repair: convert to outputs and gates.
Too broad
Includes the whole discipline. Repair: scope around the learner’s target.
No prerequisites
Assumes a common starting point. Repair: diagnose.
Calendar-first
Assigns dates before evidence. Repair: pace by milestone state.
Resource overload
Too many books and courses. Repair: one primary path.
No projects
Skills remain isolated. Repair: integrate.
No transfer gates
Course completion becomes fake mastery. Repair: independent changed outputs.
Never updated
Roadmap becomes stale. Repair: version from evidence.
The Roadmap Quality Audit
- Is the destination an independent output?
- Is the scope explicit?
- Are prerequisites diagnosed?
- Are core concepts visible?
- Are skill corridors dependency-aware?
- Do milestones test capability rather than content coverage?
- Are projects or mixed outputs included?
- Does pacing fit real weekly capacity?
- Are source roles clear?
- Are transfer gates and review cycles defined?
Roadmap Granularity: Map at the Right Scale
A roadmap can fail because it is too coarse or too detailed.
“Learn statistics” is too coarse.
“Read pages 31–34, copy three definitions, watch video 2.1” is too detailed for the strategic roadmap.
Use four levels:
Destination: useful independent capability.
Domain: major areas of the subject.
Corridor: connected sequence of dependent skills.
Next action: the immediate practice or source task.
Keep the roadmap mostly at destination, domain and corridor level. Generate next actions only for the current corridor.
The Roadmap Zoom Rule
Zoom in when the next action is unclear. Zoom out when the learner loses sight of why a task matters.
SI can move between zoom levels instantly, but the learner should not see the entire micro-task tree all at once.
The Prerequisite Graph
A list of prerequisites is useful. A graph is better when dependencies matter.
Example for data analysis:
basic arithmetic → descriptive statistics
spreadsheets or coding basics → data cleaning
descriptive statistics + data cleaning → exploratory analysis
visualisation + exploratory analysis → communication
probability foundations → statistical inference
The graph shows which paths can run in parallel and which are blocked.
Ask SI to mark prerequisites as hard, soft or optional.
Hard, Soft and Optional Prerequisites
Hard prerequisite: later skill cannot reasonably proceed without it.
Soft prerequisite: helpful but can be learned alongside the target.
Optional prerequisite: useful only for certain branches or advanced depth.
This distinction prevents the learner from spending weeks “preparing to prepare” before touching the subject.
Sequence Versus Parallel Learning
Not every topic belongs in one linear order.
Some corridors are sequential. Others can grow together.
In language learning, vocabulary retrieval and listening can develop in parallel while advanced writing may depend on both.
In coding, debugging should begin early rather than waiting until every syntax topic is completed.
In science, content learning and explanation-writing can reinforce one another.
Ask SI to identify the minimum sequence and the useful parallel work.
The Concurrency Limit
Too many parallel corridors create switching and shallow progress.
Limit the number of active build corridors based on weekly capacity.
One or two demanding corridors plus maintenance work is often easier to sustain than six simultaneous builds.
The roadmap can contain the future without activating the future all at once.
Diagnostic Gates Before Major Milestones
Before entering a new corridor, test whether the required foundations are stable enough.
A gate should be short and decision-relevant.
Before simultaneous equations, test linear equations and sign control.
Before statistical inference, test probability and descriptive statistics.
Before essay counterargument, test thesis and paragraph reasoning.
If the gate fails, repair only the blocking prerequisite rather than restarting the entire roadmap.
Exit Gates
Every corridor should end with evidence that the learner can use the capability.
Exit gates should remove familiar cues and require a changed output.
This prevents course completion from being mistaken for learning completion.
The Project Ladder
Projects can be scaled alongside the roadmap.
Micro-project: combines two or three new skills.
Checkpoint project: integrates one major corridor.
Capstone project: approximates the final independent output.
Python example: calculator → file-processing script → small command-line application.
Writing example: analytical paragraph → evidence-based article → timed or independent essay.
Data example: clean one file → exploratory notebook → end-to-end analysis and presentation.
The project ladder exposes integration problems early enough to repair them.
Projects Should Test the Roadmap, Not Decorate It
Do not add a project simply because projects sound practical.
Each project should reveal whether several roadmap components work together under realistic conditions.
If a project requires skills outside the current scope, either simplify the project or explicitly add the missing prerequisite.
Worked Roadmap: Introductory Statistics
Outcome: understand and perform basic descriptive analysis and interpret introductory statistical evidence.
Scope now: data types, centre, spread, visualisation, probability basics, sampling, confidence ideas.
Later: regression depth, advanced inference, Bayesian methods.
Prerequisites: fractions, percentages, algebra basics and graph reading.
Corridor A: data types → tables → visualisation.
Corridor B: mean/median → variability → comparison.
Corridor C: probability → sampling → uncertainty.
Project: analyse a small dataset and explain what the data support and do not support.
Transfer gate: new dataset with no step-by-step instructions.
Worked Roadmap: Conversational Language
Outcome: hold a short everyday conversation and understand common responses.
Core now: high-frequency vocabulary, pronunciation, basic sentence patterns, listening chunks, question forms.
Parallel corridors: listening discrimination and active vocabulary retrieval.
Milestone 1: introduce self and ask simple questions.
Milestone 2: handle common transactions and directions.
Milestone 3: sustain a two-minute conversation on familiar topics.
Transfer: unexpected but related prompts without a prepared script.
SI can provide abundant conversation variation while the roadmap ensures vocabulary moves into active production.
Worked Roadmap: Introductory Physics
Outcome: reason about basic motion, forces and energy using equations and conceptual models.
Prerequisites: algebra manipulation, graphs, units and proportional reasoning.
Core concepts: measurement, motion, force, energy, momentum and modelling.
Corridor: position/time → velocity → acceleration → force relationships.
Parallel corridor: energy representations and conservation.
Project: analyse motion data from a simple real or simulated experiment.
Transfer: unfamiliar scenario requiring model choice and unit checking.
Worked Roadmap: Data Analysis for Work
Outcome: take a messy business dataset, clean it, analyse a question, visualise findings and communicate limitations.
Prerequisites: spreadsheet comfort or basic code, arithmetic and domain context.
Core concepts: data quality, variables, aggregation, comparison, visualisation, uncertainty and decision relevance.
Corridor 1: import → inspect → clean.
Corridor 2: define question → choose measures → analyse.
Corridor 3: visualise → interpret → communicate.
Project ladder: one clean table → exploratory report → stakeholder-ready analysis.
Transfer gate: a new dataset with missing values and a different business question.
Worked Roadmap: Learning an Unfamiliar Professional Domain
Outcome: become conversant enough to work effectively with specialists and make sound decisions within the learner’s role.
Step 1: vocabulary and core system map.
Step 2: major processes and stakeholders.
Step 3: common metrics, risks and decisions.
Step 4: real cases and failure modes.
Step 5: produce a role-relevant deliverable or decision brief.
The roadmap avoids trying to make the learner a domain expert when the real goal is competent cross-functional work.
The Roadmap Source Stack
Assign roles to sources.
Primary path: the main course, textbook or official documentation.
Reference: authoritative source used to verify definitions and details.
Practice: questions, exercises or projects.
Alternative explanation: used only when the primary explanation fails.
Extension: optional deeper material.
SI can sit across all five roles, but it should know which role it is performing in the moment.
The Resource Replacement Rule
If a resource repeatedly fails to support the roadmap, replace it rather than stacking another resource on top.
A roadmap should not accumulate five overlapping courses because the first one was unclear.
Use SI to diagnose why the resource is failing: level mismatch, poor explanation, insufficient practice, wrong scope or outdated material.
Adaptive Pacing
Roadmaps should speed up and slow down based on evidence.
Stable prerequisites can be compressed.
Repeated transfer failure should trigger slower repair.
A real deadline may temporarily change priority.
A new project may reveal that one supposedly advanced skill is now urgently relevant.
SI can update the pacing without destroying the roadmap structure.
The Pace–Retention Check
If the learner is moving through milestones quickly but delayed retrieval is weak, the roadmap is moving faster than learning.
Use periodic retention gates before accelerating further.
The roadmap should optimise durable progress, not milestone count.
Roadmap Load Balancing
A learning roadmap exists inside a life.
School, work, family, health, travel and other subjects consume the same time and attention.
Ask SI to identify the minimum weekly workload needed to keep the roadmap moving and an optional extension for higher-capacity weeks.
Do not let every roadmap claim the learner’s best hours simultaneously.
The Recovery Week
When load has been unusually high, use a lighter week for retrieval, consolidation and review rather than abandoning the roadmap.
This maintains continuity while reducing new content.
A roadmap that cannot survive a difficult week is too brittle.
The Roadmap State Machine
Each corridor can be labelled: not started, diagnostic, repair, build, transfer, maintain, blocked or complete.
This state view is more useful than percentage complete because learning is not a linear checklist.
A corridor can move backward from maintain to repair if drift appears.
A blocked corridor can wait while another progresses in parallel.
SI can update states and show only the active corridors.
The Roadmap Dashboard
Keep six fields visible:
Destination.
Active corridors.
Current state.
Next milestone.
Blocking prerequisite.
Next review.
Everything else can live in the underlying map.
Unknown Unknowns in a New Subject
A beginner does not know what they do not know.
Ask SI to identify common beginner blind spots, essential vocabulary, typical misconceptions, major branches and the concepts experts repeatedly reuse.
Then verify the proposed map against a trusted syllabus, textbook, course outline or practitioner source.
Use unknown-unknown discovery to improve the map, not to expand the scope endlessly.
The Roadmap Blind-Spot Review
Every month ask: What important skill have I assumed but never tested? What output does the roadmap ignore? Which branch did the learner discover through practice that the original map missed?
Add only what changes the destination or a critical dependency.
A 30-Day Roadmap Launch
Days 1–3: define outcome, scope and source stack.
Days 4–7: diagnose prerequisites and create dependency graph.
Week 2: activate one or two core corridors and create first output milestone.
Week 3: add variation, mixed practice and one micro-project.
Week 4: run transfer gates, update states and revise pacing.
At day 30, the roadmap should reflect evidence from the learner rather than assumptions from the original plan.
A 90-Day Roadmap Review
Review which corridors accelerated, which remained blocked, which sources were useful and which projects exposed integration gaps.
Check whether the destination still matters and whether the scope needs expansion or contraction.
Archive completed or irrelevant corridors.
Promote stable skills to maintenance rather than continuing intensive practice.
The roadmap should become cleaner over time.
The Roadmap Decision Tree
Is the destination clear? If no, clarify output.
Is the scope bounded? If no, separate core now from later.
Are prerequisites known? If no, diagnose.
Is the active corridor blocked? If yes, repair prerequisite.
Is the milestone passed? If no, practise or repair.
Is transfer stable? If no, vary context and remove cues.
Is the skill retained? If yes, move to maintenance.
This decision tree keeps the roadmap responsive to learning state.
The Roadmap Exit Test
A roadmap phase is complete when the learner can produce the target output independently, explain core concepts, handle normal variation, recover from common errors and know where to find authoritative reference material.
Completion does not mean knowing everything in the subject.
It means the learner has reached the destination that defined the roadmap.
The strongest learning roadmap makes the subject finite enough to enter, structured enough to navigate and evidence-driven enough to change when the learner changes.
Depth: Orientation, Practical, Academic or Professional
The same subject can support several different destinations.
Orientation depth: understand the vocabulary and major ideas well enough to follow conversations.
Practical depth: perform useful tasks independently.
Academic depth: understand formal models, evidence, theory and assessed material.
Professional depth: perform reliably under real standards, constraints and consequences.
A roadmap should state the intended depth before choosing resources. Otherwise the learner may study professional detail for an orientation goal or stop at beginner intuition when formal mastery is required.
Ask SI to build two or three roadmap variants at different depths and compare what changes. The difference reveals what is genuinely required for the learner’s destination.
The Minimum Useful Depth
When time is limited, identify the minimum depth that produces the desired output safely and competently.
A manager may need enough statistics to interpret reports and ask good questions, not enough to become a statistician. A traveller may need functional language for everyday interaction, not literary fluency. A student needs the curriculum depth and transfer required by assessment, not an entire university treatment of the topic.
Depth should be purposeful rather than prestigious.
The Prior-Knowledge Transfer Audit
A learner entering a new subject is rarely starting from zero.
An engineer learning economics may already understand modelling. A writer learning law may already understand argument and evidence. A bilingual learner may already recognise grammatical ideas that transfer into another language. A spreadsheet user learning Python may already understand tables and formulas.
Ask SI to identify which existing capabilities are likely to transfer, then test them.
Do not skip prerequisites based only on confidence. A transferable skill should be demonstrated inside the new subject.
Transfer Credit for Learning
Treat stable prior knowledge like transfer credit. Remove redundant beginner stages and spend time where the new subject genuinely differs.
This can dramatically shorten a roadmap for adults and interdisciplinary learners.
It also prevents boredom caused by generic courses that assume every learner has the same background.
The Roadmap State Model
A roadmap becomes useful when every node has a state.
Not started: no evidence yet.
Diagnostic needed: prior knowledge uncertain.
Active: currently learning.
Guided: can perform with support.
Independent: can perform alone.
Transferred: can use the skill in a changed context.
Stable: retained after delay.
Blocked: prerequisite or external constraint missing.
Postponed: deliberately deferred because it is not currently needed.
The state model prevents the roadmap from becoming a checklist where every completed reading looks equivalent to mastery.
State Transitions Need Evidence
Move a node from guided to independent only after unaided performance. Move it to transferred only after changed-context success. Move it to stable only after delayed review.
SI can maintain the roadmap state, but learner performance must drive the transitions.
The Resource Layer
A roadmap needs sources, but resource abundance can become a learning tax.
Choose one primary structural resource per stage: textbook, course, official documentation, syllabus or carefully selected guide.
Use SI for explanation, diagnostics, practice and integration around that source.
Add secondary resources only when they solve a specific problem the primary source does not solve.
This prevents the learner from spending more time comparing resources than using them.
The Source Hierarchy
For school learning, curriculum and current teacher materials define the required scope. For coding, current official documentation is the strongest authority for library behaviour. For professional domains, current standards and expert sources matter. For research-heavy topics, primary sources and appropriate scholarly evidence should anchor claims.
A roadmap should know where truth is checked when SI and a resource disagree.
Time-Budgeting the Roadmap
A roadmap without a realistic weekly capacity is a wish list.
Use sustainable hours, not maximum hours.
Split time among new learning, retrieval, practice, project work and review.
Example for six hours a week: two hours foundation and new concepts, two hours application, one hour retrieval and review, one hour project integration.
As the learner advances, shift the ratio away from explanation toward application, transfer and projects.
The Capacity Constraint
If the roadmap requires ten hours and the learner has five, do not assume motivation will create the missing five.
Reduce scope, extend the timeline, defer optional branches or choose the highest-leverage corridor.
SI should make the roadmap fit the learner’s life rather than produce an idealised full-time curriculum.
The Minimum Viable Foundation
Do not wait to master every prerequisite before applying the subject.
Identify the smallest foundation that unlocks a meaningful first task.
For Python automation, variables, strings, lists, conditions, loops and functions may be enough to begin a useful file-processing project.
For a language, pronunciation, high-frequency vocabulary and basic sentence patterns can support a simple conversation long before full grammar coverage.
For data analysis, tables, descriptive statistics and chart selection can unlock a first real dataset before advanced inference or machine learning.
Application reveals which foundation gaps are actually blocking progress.
Foundation–Application Cycles
Use cycles rather than one giant foundation phase.
Foundation → small application → diagnose → repair → broader foundation → larger application.
This keeps the learner oriented toward use and creates evidence for the next roadmap revision.
Worked Roadmap: Learning a New Language
Destination: handle everyday conversation and short practical writing.
Stage 1: sound system, pronunciation and high-frequency phrases.
Stage 2: core vocabulary and sentence patterns for present, past, future, questions and negation.
Stage 3: controlled listening and reading with frequent known vocabulary.
Stage 4: speaking and writing using active retrieval.
Stage 5: topic expansion, natural phrasing, idiom and spontaneous interaction.
Milestones are communicative: ask for directions, describe yesterday, arrange a meeting, write a message, sustain a conversation.
Grammar supports these outputs rather than becoming the entire roadmap.
Worked Roadmap: Learning Economics
Destination: analyse everyday market and policy questions using core economic reasoning.
Stage 1: scarcity, opportunity cost, incentives and marginal thinking.
Stage 2: supply, demand, elasticity and equilibrium.
Stage 3: firms, costs, competition and market failure.
Stage 4: GDP, inflation, unemployment, money, fiscal and monetary policy.
Stage 5: trade, exchange rates and policy evaluation.
At every stage, apply the model to a real case and ask what assumptions limit the conclusion.
Worked Roadmap: Learning Data Analysis
Destination: answer practical questions from real datasets and communicate findings.
Stage 1: data types, tables, cleaning and spreadsheet fluency.
Stage 2: descriptive statistics and distributions.
Stage 3: chart selection and visual communication.
Stage 4: sampling, uncertainty and basic inference.
Stage 5: Python or another tool for larger workflows.
Stage 6: end-to-end projects with messy data and written interpretation.
Projects appear early enough that the learner sees why the tools matter.
Worked Roadmap: Learning to Write Better
Destination: produce clear analytical writing independently.
Stage 1: sentence clarity, paragraph claim and evidence.
Stage 2: reasoning between evidence and claim.
Stage 3: structure across paragraphs.
Stage 4: counterargument, synthesis and precise vocabulary.
Stage 5: editing for audience, tone and concision.
Milestones use original writing. Reading about writing supports the output but does not replace it.
Project-Based Roadmapping
Projects can become the applied spine of a roadmap.
Choose a project just beyond current ability. Decompose the missing capabilities. Learn each capability as the project requires it. Integrate and review.
The project should be difficult enough to reveal gaps and small enough that the learner still does most of the work.
The Project Ladder
Project 1: tiny and guided.
Project 2: similar but independent.
Project 3: different context.
Project 4: integrated real-world output.
Project 5: learner-designed project with minimal support.
The project ladder turns roadmap knowledge into increasingly independent capability.
Branches and Optionality
A subject often branches after a common foundation.
Programming may branch into web, automation, data or embedded systems. A language may branch into academic reading, travel communication or business use. Mathematics may branch into statistics, calculus or discrete mathematics.
Do not force the branch choice before the learner has enough exposure to understand the trade-off.
Use a small task from each branch to create evidence about fit.
The Branch Test
For each branch, ask what outputs it enables, which prerequisites are unique, what time commitment it adds and how reversible the choice is.
Then choose based on the learner’s destination rather than prestige or novelty.
Roadmap Failure Modes
Topic dumping: long list with no dependencies. Repair by showing corridors and gates.
Prerequisite perfectionism: learner waits to master every foundation before applying. Repair with minimum viable foundation and projects.
Project too late: theory accumulates without use. Add a smaller project earlier.
Project too early: SI ends up performing most of the work because prerequisites are missing. Shrink the project or strengthen the foundation.
Too many resources: learner compares courses instead of learning. Choose a primary source.
No milestone gates: learner advances by calendar rather than capability.
No review: roadmap stays fixed after reality changes.
Roadmap becomes the goal: learner optimises completion percentage rather than useful skill.
The Roadmap Review Questions
- Which milestone was easier than expected?
- Which prerequisite was missing?
- Which topic can be postponed?
- Which topic needs more transfer practice?
- Which project revealed the most useful gap?
- Which resource is redundant?
- Is the destination still the same?
- Does the weekly load fit reality?
- What is the next bottleneck?
A roadmap should become simpler and more accurate as evidence accumulates.
The Copyable Roadmap Specification
Destination: independent output.
Depth: orientation / practical / academic / professional.
Baseline: current stable knowledge.
Prerequisite corridors: dependencies.
Parallel corridors: what can run together.
Minimum foundation: what unlocks first use.
Projects: applied tasks.
Milestones: capability gates.
Sources: correctness hierarchy.
Weekly capacity: sustainable hours.
State: active / blocked / transferred / stable.
Review: cadence and rerouting rule.
A Copyable Learning Roadmap Prompt
“Help me turn this subject into a learning roadmap. My target independent output is __. My current background is __. First map major domains, prerequisites, procedures and outputs. Show true prerequisites versus topics that can run in parallel or wait. Identify the minimum viable foundation that unlocks an early project. Build milestone gates based on independent performance, not chapter completion. Assign one primary resource type per stage, include retrieval, practice, transfer and review, fit the roadmap to __ hours per week, and explain how to reroute when diagnostics show a gap.”
The Final Roadmap Rule
A roadmap is useful only while it helps the learner decide what to do next.
Do not preserve a beautiful map after the learner’s evidence says the route has changed.
Build the route quickly, travel it actively, and let real performance redraw the map.
Roadmap Governance: Who Is Allowed to Change the Plan?
A roadmap becomes unstable when every new idea changes the sequence.
Define which evidence is allowed to change the roadmap.
Good triggers include failed prerequisite gates, repeated transfer failure, a new real deadline, changed learning goal, updated syllabus or a project revealing an important missing skill.
Weak triggers include one interesting video, one difficult day or a new SI suggestion that is not connected to the destination.
SI may recommend a roadmap change. The learner, teacher, tutor or legitimate decision-maker should approve material changes.
The Roadmap Change Log
For important changes, record: what changed, why, which evidence triggered it and what downstream milestones moved.
This protects the roadmap from becoming a history of unexplained edits.
It also makes later review more useful because the learner can see which assumptions were wrong.
Milestone Metrics
Choose metrics that match the capability.
For Mathematics: independent accuracy on changed and mixed questions, help level and timed completion.
For language: active recall, spontaneous production, listening comprehension and transfer across topics.
For coding: ability to implement from a requirement, debug, explain and modify code.
For writing: claim quality, evidence use, explanation, organisation, revision and performance under time.
For professional skill: quality of realistic deliverable and ability to justify judgement.
Do not use one metric such as hours studied across every corridor.
Activity Metrics Versus Capability Metrics
Pages read, videos watched and exercises completed are activity metrics.
They can help track consistency but should not substitute for capability metrics.
Use activity to explain effort. Use capability to decide whether the roadmap should advance.
The Roadmap Evidence Ledger
Keep a lightweight ledger for major milestones.
Milestone: what capability.
Evidence: representative task or project.
Help level: none, cue, hint or scaffold.
Transfer: changed task result.
Retention: delayed result if relevant.
Status: repair, build, transferred or maintain.
This ledger gives SI enough context to update the roadmap without rereading the entire history.
Roadmap Confidence
Not every part of a new-subject roadmap is equally certain.
Mark major corridors as source-grounded, inferred from common learning sequences or provisional.
When the roadmap is built for a formal curriculum, rely more heavily on official structure. When the goal is a self-directed professional skill, roadmap design may require more experimentation.
A provisional roadmap is acceptable if it is easy to revise and has early evidence gates.
The Source Verification Pass
Before committing to a long roadmap, verify the structure against reliable sources.
School subject: official syllabus, exam specification, textbook and teacher requirements.
Software: current official documentation and maintained examples.
Professional certification: current official competency or exam framework.
Academic field: reputable introductory text or course sequence.
SI can propose a roadmap. Verification ensures the structure has not invented prerequisites, omitted essentials or relied on outdated conventions.
The Source Freshness Rule
Fast-moving subjects need roadmap freshness.
Software libraries, regulations, certification requirements and technical practices can change. Date the source frame and schedule periodic checks.
Foundational mathematics may need less frequent source review than a current cloud platform.
Worked Roadmap: Machine Learning Foundations
Outcome: understand and implement basic supervised-learning workflows and evaluate simple models.
Scope now: data preparation, train/test split, regression/classification concepts, loss, overfitting, evaluation, simple models.
Prerequisites: Python basics, algebra, basic probability and data handling.
Corridor A: data → features/target → split.
Corridor B: model → prediction → loss.
Corridor C: evaluation → overfitting → validation.
Micro-project: train and evaluate one simple model.
Transfer gate: new dataset and different target with no tutorial sequence.
Later: neural networks, advanced optimisation and deployment.
Worked Roadmap: Primary Science Explanation Skills
Outcome: answer open-ended science questions with accurate concepts, keywords and causal explanation.
Prerequisites: topic knowledge, reading comprehension and basic scientific vocabulary.
Core concepts: structure-function, cause-effect, energy, cycles and systems according to the curriculum.
Corridor 1: identify concept → retrieve key terms.
Corridor 2: cause → mechanism → effect.
Corridor 3: evidence from diagram or scenario → explanation.
Milestone: oral explanation accurate before writing.
Transfer: unfamiliar scenario using the same concept.
Worked Roadmap: Secondary English Vocabulary to Writing
Outcome: use a stronger vocabulary naturally in independent writing.
Prerequisite: basic sentence control and reading comprehension.
Corridor 1: recognition → meaning discrimination.
Corridor 2: active recall → sentence use.
Corridor 3: paragraph integration → tone and register.
Project: descriptive or argumentative piece using selected words without forcing them.
Transfer gate: new topic with no word bank visible.
Worked Roadmap: Project Management
Outcome: plan, monitor and communicate a small project competently.
Core concepts: scope, dependencies, milestones, risk, stakeholder, ownership, change and review.
Corridor A: outcome → scope → task/dependency map.
Corridor B: risk → trigger → mitigation → owner.
Corridor C: status → decision → communication.
Project: manage a small real or simulated initiative.
Transfer: diagnose a delayed project and produce a recovery plan.
Roadmaps for Examination Preparation
Exam roadmaps need two layers: knowledge/skill repair and performance under exam conditions.
Do not begin with full papers if prerequisites remain unstable.
Sequence: diagnostic by topic → repair corridors → mixed sections → timed sections → full papers → error review → targeted re-repair.
SI can generate topic diagnostics and changed questions while past papers or official exam material provide the performance frame.
The Exam Countdown Rule
As the assessment approaches, the roadmap should shift from broad building toward retrieval, integration, timing and error control.
Do not introduce large new branches late unless they are essential and high-yield.
The roadmap phase changes with time-to-need.
Roadmaps for Lifelong Learning
Not every roadmap has an exam or fixed end date.
For lifelong learning, use capability horizons instead of a final completion state.
Horizon 1: functional beginner.
Horizon 2: independent practitioner.
Horizon 3: advanced or specialist capability.
The learner can stop at any horizon that serves their life goal.
This prevents the subject from becoming infinite simply because deeper knowledge exists.
Roadmap Branching
At higher levels, the roadmap may branch.
Programming can branch into web development, data, automation or systems.
Economics can branch into microeconomics, macroeconomics, econometrics or policy.
Writing can branch into academic, creative, professional or technical writing.
Delay branch selection until the learner has enough exposure to choose meaningfully.
The Roadmap Motivation Layer
Motivation is easier when milestones produce visible capability.
Projects, changed tasks and real outputs are stronger progress signals than course percentages alone.
Ask SI to connect each corridor to a practical use so the learner knows why it exists.
Do not manufacture gamification if the learner does not need it. Progress evidence can be motivating enough.
The Roadmap Friction Log
When the learner repeatedly avoids one corridor, record the friction before labelling it motivation.
Is the source unclear? Is the prerequisite missing? Is the task too large? Is feedback delayed? Is the output irrelevant? Is weekly capacity unrealistic?
Repair the system where possible.
The Roadmap Portfolio Rule
A person may have several roadmaps at once: school subjects, professional learning, language, fitness knowledge or hobbies.
Review them as a portfolio.
Which roadmap is in intensive build?
Which is maintenance?
Which can pause?
Which has a real deadline?
Do not optimise each roadmap independently until the total weekly load becomes impossible.
The One-Major-Build Rule
For many adults, one major new learning build plus smaller maintenance streams is more sustainable than several simultaneous intensive subjects.
The exact number varies, but the principle is useful: deep learning competes for high-quality attention.
The Roadmap Handoff to a Tutor or Teacher
If a human educator becomes involved, share the destination, active corridors, evidence, blocked prerequisites and upcoming milestone.
Do not hand over a giant SI-generated curriculum and ask the teacher to validate everything.
Use the roadmap as a concise current-state map that the educator can correct.
The Roadmap Handoff to a Personal SI Tutor
The roadmap tells the tutor what corridor is active and what exit gate matters.
The tutor then handles diagnosis, explanation and practice inside that corridor.
This division keeps the tutor from wandering into interesting but low-priority topics.
The Roadmap Anti-Dependency Rule
The learner should gradually understand the roadmap well enough to make basic navigation decisions.
Which corridor am I in?
What prerequisite is blocking me?
What evidence lets me move on?
What should I maintain rather than relearn?
SI can propose the route, but the learner should increasingly see the structure themselves.
The Roadmap Ownership Sentence
At each major review, the learner should be able to say: “I am learning ___ because ___. I am currently building ___. I know I can move on when ___. The main thing blocking me is ___.”
This keeps the roadmap in the learner’s understanding rather than only inside the system.
The Roadmap Simplification Review
Every few weeks, ask what can be removed.
Delete redundant resources.
Archive completed corridors.
Merge overlapping milestones.
Remove optional topics that no longer support the destination.
Simplification keeps the roadmap navigable as knowledge grows.
The Final Roadmap Rule
A roadmap should become more accurate as the learner moves through it.
The first version is a hypothesis about the route. Diagnostics, projects and transfer tests turn that hypothesis into a personalised learning system.
Use Super Intelligence to map the territory quickly, then let learner evidence decide which road is actually shortest.
A Learning Roadmap Is Not a Table of Contents
A table of contents tells you what exists in a subject. A learning roadmap tells you what to learn first, what depends on what, what can wait, what evidence proves progress and what should happen when the learner gets stuck.
This distinction matters because many subjects are presented as lists of topics. A beginner sees twenty chapters and assumes they should move from Chapter 1 to Chapter 20 in order. Real learning is usually more structured. Some concepts are prerequisites. Some are optional. Some must be revisited. Some are best learned through projects. Some can be skimmed until a later need appears.
Super Intelligence becomes useful when it converts a subject from a content pile into a dependency-aware path.
The Learning Roadmap Spine
Use seven layers: Outcome → Scope → Prerequisites → Core Concepts → Practice Corridors → Mastery Gates → Transfer.
Outcome
What should the learner be able to do independently at the end?
Scope
What part of the subject belongs in this roadmap, and what deliberately stays outside it?
Prerequisites
Which prior concepts, vocabulary, skills or tools must already be stable?
Core concepts
Which ideas organise the subject and explain many later details?
Practice corridors
Which repeated actions convert understanding into usable skill?
Mastery gates
What evidence allows the learner to move forward?
Transfer
How will the learner prove that the knowledge works outside the original lesson format?
This spine turns the roadmap into a learning control system rather than a decorative outline.
Start with the Output, Not the Subject Name
“Learn economics” is too broad. “Understand enough microeconomics to explain supply, demand, elasticity and market structure, then analyse a simple business case” is a usable outcome.
“Learn Python” is too broad. “Write, debug and explain small Python programs using variables, conditionals, loops, functions and files” creates a bounded path.
“Learn Secondary 1 Mathematics” becomes more operational when the roadmap identifies the actual school outputs: solve unfamiliar questions, show working, choose methods correctly and perform under assessment conditions.
Ask SI: “Define three possible end states for this subject: beginner literacy, working competence and advanced capability. For each, give me the observable output that would prove it.”
The learner can then choose the level that matches the real goal instead of accidentally building a roadmap for the entire discipline.
The Scope Fence
A roadmap needs an explicit fence.
Without one, SI can keep adding adjacent concepts because they are interesting or useful. The result becomes academically rich and operationally impossible.
Write:
Inside scope: concepts and skills needed for the chosen outcome.
Outside scope for now: advanced topics, specialist branches, optional theory or tools that can wait.
Future branch: topics that become relevant only after the current mastery gate.
This simple fence protects learning velocity.
Prerequisite Mapping
Most slow roadmaps fail because prerequisites are discovered late.
A learner reaches a difficult topic, struggles, and assumes the topic itself is too hard. In reality, one earlier skill may be unstable.
Ask SI to produce a prerequisite graph rather than a flat list.
For algebra, negative numbers and arithmetic may support expansion, which supports equations, which supports algebraic applications.
For coding, variables and control flow may support functions, which support modular programs, which support larger projects.
For writing, sentence control and active vocabulary may support paragraph development, which supports argument structure and full essays.
The roadmap should test the prerequisites rather than assume them.
The Prerequisite Gate
Before entering a major module, define one or two diagnostic tasks that prove the required foundation is ready.
Do not demand perfect mastery of every background skill. Require enough stability that the new module can be learned without constant repair.
If the gate fails, create a short repair branch, not a complete restart.
Core Concepts Versus Supporting Detail
A new subject often contains many facts and a smaller number of organising ideas.
Identify the core concepts that explain large parts of the subject.
In economics, opportunity cost, incentives, marginal change and equilibrium organise many later topics.
In computing, abstraction, state, control flow and decomposition recur across many tools and languages.
In grammar, sentence structure, tense, agreement and modification organise many surface rules.
Ask SI: “Which five to ten concepts explain the largest share of this subject at my chosen level? Which details are examples, applications or exceptions of those concepts?”
Core concepts deserve more retrieval, explanation and transfer than supporting details.
The Concept Anchor
For each major module, write one sentence answering: “What idea should still be true after I forget the examples?”
This anchor becomes the compression point for later review.
Sequence by Dependency, Not Popularity
The most exciting topic is not always the best first topic.
Sequence modules according to dependency and information value.
Ask three questions:
- What must be known before this module makes sense?
- What later modules depend on it?
- Would learning this early make several later ideas easier?
High-dependency concepts usually move earlier in the roadmap.
Parallel Learning Lanes
Not every module needs to be strictly sequential.
A learner can sometimes run a knowledge lane and a practice lane together.
Example: language learning can combine core grammar, vocabulary retrieval and listening from the beginning. Coding can combine syntax learning with one small project. History can combine chronology with source analysis.
Ask SI which lanes are independent enough to run in parallel without overloading working memory.
Practice Corridors
Every roadmap needs a repeatable corridor that converts concepts into capability.
Mathematics corridor: concept → guided example → independent question → changed question → mixed question → timed set.
Vocabulary corridor: meaning → retrieval → sentence → contrast → paragraph → delayed use.
Coding corridor: concept → trace code → edit code → write code → debug code → build feature.
Professional learning corridor: concept → case → analysis → real deliverable → feedback → revised deliverable.
The corridor should appear repeatedly throughout the roadmap so each new module follows a familiar learning rhythm.
The Practice Ratio
As the learner progresses, the roadmap should shift from explanation-heavy to practice-heavy.
Early module: more explanation and guided practice. Middle module: more independent application. Later module: more transfer, integration and realistic performance.
SI can adjust the ratio based on evidence instead of keeping every lesson equally explanatory.
Mastery Gates
A roadmap needs gates that decide when the learner may progress.
A gate should test the capability required by the next module.
For a coding roadmap, a gate before object-oriented programming may require writing and debugging several functions independently.
For Mathematics, a gate before equations may require stable algebraic manipulation.
For writing, a gate before full argumentative essays may require clear paragraph claims, evidence and explanation.
Do not let the roadmap advance simply because a calendar week ended.
Hard Gate and Soft Gate
Hard gate: later learning will fail without this capability. Do not advance until stable.
Soft gate: progress can continue while the skill improves in parallel.
This distinction prevents perfectionism from slowing the entire roadmap.
Timeboxing a Roadmap Without Letting the Calendar Lie
Roadmaps often fail because dates are treated as mastery.
A learner says, “Week 2 is algebra, Week 3 is equations,” even if algebra remains unstable.
Use timeboxes as planning estimates, not automatic promotion rules.
Each module should have an expected duration, minimum evidence and extension rule.
If the gate fails, extend or repair. If the learner masters early, advance.
The Pace Dial
Adjust pace using three signals: accuracy, independence and retention.
High accuracy + high independence + delayed retention → accelerate.
High accuracy + heavy hints → maintain topic but reduce support.
Low accuracy at an early prerequisite → slow down and repair.
Variable performance under mixed tasks → integrate before advancing.
Resources Belong to Modules, Not to the Roadmap as a Giant List
A common failure is collecting too many books, videos, courses and links before learning starts.
Attach only the resources needed for the current module.
Each module can have:
Primary source: textbook, documentation, course or trusted reference.
Explanation source: optional alternative explanation.
Practice source: questions, exercises or projects.
Verification source: answer key, official documentation, teacher or expert feedback.
SI can generate supplementary practice, but the roadmap should keep a trusted source of correctness.
The Resource Ceiling
Limit resource acquisition until a real gap appears.
One core text plus SI-assisted explanation and practice is often more effective than five overlapping courses.
More resources are justified when the learner needs another explanation, more practice, a different modality or authoritative depth.
Projects as Roadmap Integrators
A project can force several modules to work together.
For coding: build a small application. For data analysis: analyse a real dataset. For writing: produce an essay or report. For language: record a spoken presentation and write a related piece. For business learning: create a market analysis or operating plan.
Projects expose interface failures that isolated exercises miss.
Use SI to propose projects at three difficulty levels and identify which roadmap skills each project integrates.
The Project Gate
Do not wait until the very end for the first project.
Use small projects after clusters of modules, then a larger capstone later.
This creates regular evidence that the roadmap is producing usable capability.
A Full Roadmap Example: Learning Python
Outcome: build and debug small Python programs independently.
Prerequisite gate: basic computer file use and comfort reading simple code examples.
Module 1: variables, values and simple input/output.
Module 2: conditionals.
Module 3: loops and iteration.
Integration project: small text-based program.
Module 4: functions and decomposition.
Module 5: lists, dictionaries and data manipulation.
Module 6: file input/output and error handling.
Capstone: small useful program with functions, data structures and files.
Each module follows trace → edit → write → debug → explain. Mastery gates require fresh tasks, not repeated examples.
A Full Roadmap Example: Learning Secondary Mathematics
Outcome: solve current school-level unfamiliar problems independently and under assessment conditions.
Prerequisite layer: number fluency, fractions, percentages and negative numbers.
Algebra lane: expressions → expansion → equations → algebraic applications.
Geometry lane: angle facts → properties → area/volume → multi-step geometry.
Data lane: representation → averages → interpretation.
Execution lane: reading, working, checking and time control.
Topics can run in school order while prerequisite repair branches operate underneath. Mixed practice and timed papers appear only after the relevant methods are sufficiently stable.
A Full Roadmap Example: Learning Academic Writing
Outcome: produce clear evidence-based essays independently.
Foundation: sentence clarity, paragraph structure, active vocabulary and source handling.
Module 1: claim and paragraph focus.
Module 2: evidence and explanation.
Module 3: essay architecture and transitions.
Module 4: counterargument and qualification.
Module 5: source synthesis and citation discipline.
Capstone: full essay under time or length constraints with independent revision.
SI can critique drafts and generate exercises, but the learner must write before seeing a replacement version.
A 30-Day Roadmap
For a bounded subject or beginner layer, use four phases.
Week 1 — Orientation: outcome, scope, prerequisite diagnosis and first core concepts.
Week 2 — Foundation: practise the highest-dependency skills and establish retrieval.
Week 3 — Application: changed tasks, integration and one small project.
Week 4 — Transfer: mixed tasks, delayed review, capstone or realistic output and roadmap revision.
This is not enough for every subject. It is a useful first learning cycle.
A 90-Day Roadmap
Month 1: map and foundation.
Month 2: application, varied practice and projects.
Month 3: integration, performance under realistic conditions, delayed transfer and capstone review.
Review the roadmap monthly. Remove topics that no longer serve the chosen outcome and add repair branches only when evidence requires them.
Roadmap Drift
A roadmap drifts when the learner begins collecting adjacent material that does not serve the current goal.
Common drift signals include too many resources, unfinished modules, expanding scope, repeated restarts and new topics added before current gates are passed.
Use SI to run a monthly drift review: Which items were added? Which are essential? Which belong in a future branch? Which active module is currently blocking progress?
Roadmap Debt
Roadmap debt appears when old modules, notes, prompts and resources remain active after the learning path has changed.
Archive completed or abandoned branches. Keep the current roadmap readable.
A small current map is more useful than a giant archive of everything once considered.
The Roadmap Review Every Four Weeks
- Which mastery gates passed?
- Which prerequisite remains unstable?
- Which module took longer than expected?
- Which resource created the most value?
- Which topic was unnecessary?
- Where did transfer fail?
- What project or output now best tests integration?
- What should be removed from the roadmap?
The review keeps the roadmap responsive to evidence rather than loyal to the original plan.
The Roadmap State Model
Label modules as future, ready, active, blocked, review, mastered or archived.
A module becomes ready when prerequisites pass. It becomes active when the learner begins. It becomes blocked when a prerequisite or resource fails. It becomes review when practice is complete but transfer is not yet proven. It becomes mastered after the gate. It becomes archived when it is no longer relevant.
This state model prevents every topic from feeling simultaneously active.
A Copyable Learning Roadmap Prompt
“Turn this subject into a learning roadmap for my specific goal. First define three possible mastery levels and ask me to choose one. Then create a scope fence, prerequisite map, core concepts, practice corridors and mastery gates. Sequence by dependency rather than chapter order. Mark which modules can run in parallel. Attach only the minimum resources needed for the current module. Include small integration projects, delayed transfer tests, review dates and a rule for repairing failed prerequisites. Keep the roadmap adaptive: module state should change only when performance evidence supports it.”
The Roadmap Preflight
- Is the final independent output clear?
- Is the scope bounded?
- Are prerequisites tested?
- Are core concepts separated from supporting detail?
- Is sequence based on dependency?
- Does each module contain practice?
- Are mastery gates observable?
- Is transfer tested?
- Are resources limited?
- Is there a review and drift-control rule?
The Final Roadmap Rule
A roadmap is not a promise that learning will follow a perfect sequence.
It is a current model of the shortest sensible path from today’s capability to the chosen independent output.
When performance reveals a missing prerequisite, repair it. When a module stabilises early, advance. When a topic does not serve the outcome, remove it. When transfer fails, revisit the exact interface rather than restarting everything.
Super Intelligence makes roadmap construction cheap. The learner’s performance decides whether the roadmap is true.
Sequencing Heuristics: What Usually Comes First?
When a subject is unfamiliar, sequencing rules help prevent arbitrary ordering.
Vocabulary before dense theory: learn the minimum language needed to understand instructions and explanations.
Prerequisites before dependent procedures: repair the foundation that later steps assume.
Concrete before abstract when the abstraction has no anchor: begin with examples, then generalise.
Use before optimisation: get a simple method working before refining performance.
Single skill before integration: stabilise a difficult component before mixing it into a larger task.
Integration before mastery claims: a skill that works only in isolation is not yet complete.
These are heuristics, not universal laws. SI should adjust them when the subject or learner requires a different route.
The Sequencing Conflict Test
Sometimes two topics appear to depend on one another.
Example: a coding learner needs functions to build useful projects but also needs projects to understand why functions matter.
Resolve the loop with a shallow-first cycle: learn the minimum concept, apply it, then deepen the concept after the application creates context.
Ask SI to identify circular dependencies and propose a spiral sequence rather than forcing a strict linear order.
The Assessment Map
A learning roadmap should specify how each stage will be assessed.
Not every stage needs a test. It does need evidence.
Knowledge stage: retrieval without notes.
Concept stage: explanation, classification or counterexample.
Procedure stage: independent execution.
Recognition stage: choose the method without labels.
Transfer stage: changed context.
Integration stage: realistic mixed project or assessment.
SI can generate the assessment tasks, but the evidence should come from the learner’s output.
Assessment Before Advancement
Roadmap advancement should be evidence-based.
If the learner cannot pass the milestone, do not simply schedule more of the next topic. Identify whether the gap is prerequisite, recognition, execution or transfer.
The roadmap should branch into repair, not keep advancing because the calendar says so.
The Knowledge-Gap Overlay
As the roadmap runs, maintain a separate overlay for open gaps.
The roadmap says where the learner intends to go. The gap overlay says what currently blocks progress.
Each gap should include the affected milestone, evidence, likely prerequisite, repair task and retest.
Do not rewrite the entire roadmap every time a small gap appears. Use the overlay to route short repairs while preserving the larger path.
Gap Severity
Local gap: affects one task only.
Corridor gap: affects several downstream topics.
System gap: affects study method, language, tool use or another capability across the subject.
Repair corridor and system gaps early because they create repeated downstream cost.
Roadmap Drift
Roadmaps drift when the learner’s real path slowly separates from the planned path.
Common causes include changing goals, unexpected prerequisites, new opportunities, resource changes, illness, school pace, work demands or discovering that one branch is more relevant than expected.
Drift is not automatically failure. It becomes a problem when the map no longer describes the learner’s current target or workload.
The Roadmap Drift Review
Ask once a month: What are we actually learning now? Which milestones still matter? Which branch has become irrelevant? Which new prerequisite appeared? Is the destination unchanged?
If the answers differ materially from the map, version the roadmap rather than layering more corrections onto the old one.
Roadmap Versioning
Use simple versions: v1 baseline, v2 after first project, v3 after branch choice.
Record what changed and why.
Example: “v2 removes two introductory topics because baseline diagnostics showed stable mastery and adds one statistics prerequisite revealed by Project 1.”
Versioning preserves learning history and prevents the learner from repeatedly rediscovering why the path changed.
The Roadmap Compression Rule
As the roadmap matures, compress it.
Move stable prerequisites out of the active view. Keep current corridors, open gaps, next milestones and the destination.
A mature roadmap should become easier to inspect, not larger forever.
A 30-Day Roadmap Launch
Days 1–3: define destination, depth and weekly capacity.
Days 4–6: run prerequisite and prior-knowledge diagnostics.
Days 7–10: build the major subject map, corridors and minimum foundation.
Days 11–17: begin the first corridor and complete one small application.
Days 18–24: repair gaps revealed by the application and continue foundation.
Days 25–28: run the first milestone gate.
Days 29–30: review the roadmap, remove redundant topics and set the next milestone.
The first month is not meant to finish the subject. It is meant to validate the route.
A 90-Day Roadmap Cycle
Month 1 — Foundation and first use: minimum prerequisites plus one small project.
Month 2 — Expansion and variation: broaden the concept map, increase application and introduce transfer.
Month 3 — Integration and branch choice: complete a larger project, run delayed milestone tests and decide which branch or next depth is justified.
At 90 days, the learner should have evidence about both capability and fit.
Worked Roadmap: Learning Basic Law for Non-Lawyers
Destination: understand legal reasoning and common legal documents well enough to prepare informed questions for qualified professionals.
Stage 1: legal systems, sources of law, statutes, cases and jurisdiction.
Stage 2: reading cases: issue, rule, reasoning, outcome.
Stage 3: contracts, obligations, liability and basic legal terminology relevant to the learner’s context.
Stage 4: analyse sample documents and separate general information from advice requiring a lawyer.
Milestone: explain the structure of a simple legal problem and prepare accurate questions without pretending to provide professional legal advice.
Worked Roadmap: Learning Biology
Destination: understand core biological systems and explain them using evidence and mechanism.
Stage 1: cells, molecules and energy.
Stage 2: genetics and information flow.
Stage 3: physiology and interacting organ systems.
Stage 4: ecology and evolution.
Across every stage, use diagrams, causal explanation, prediction and changed examples rather than memorising isolated terms.
Milestone: explain a biological process, predict what changes when one component changes and connect the process to a larger system.
Worked Roadmap: Learning AI for Practical Use
Destination: use modern AI systems effectively while understanding their limits, verification needs and workflow implications.
Stage 1: core vocabulary: model, prompt, context, tool, retrieval, agent, hallucination.
Stage 2: practical prompting, context design and verification.
Stage 3: reusable workflows and connected tools.
Stage 4: evaluation, privacy, permissions and human oversight.
Stage 5: domain-specific projects that produce measurable value.
Milestone: design and review a useful workflow where the human can explain the inputs, checks, permissions and failure modes.
The Roadmap Portfolio
People often learn several things at once.
Do not optimise every roadmap independently. They share time, attention and energy.
A learner may be studying Mathematics, English, coding and a professional course. Each roadmap can be reasonable while the combined portfolio is impossible.
Use SI to identify shared prerequisites, duplicated practice and competing high-energy tasks.
Choose one primary growth roadmap and keep others at maintenance when capacity is limited.
The Cross-Roadmap Synergy Test
Some learning projects reinforce one another.
Writing improves professional communication. Statistics supports data analysis. Coding supports automation. Vocabulary supports reading and writing. Project management supports many applied learning tasks.
Ask SI to identify shared capability nodes that can serve several roadmaps at once.
This can create genuine leverage without increasing total study time.
The Roadmap Exit Test
A roadmap has done its job when the learner no longer needs the map to decide every next step.
The learner understands the subject structure, can diagnose gaps, can choose appropriate resources, can build projects and can decide which branch or depth comes next.
At that point, the roadmap becomes a reference rather than a controller.
The final product of a good roadmap is not dependence on planning. It is a learner who can navigate the subject independently.
Frequently Asked Questions
Can SI create a learning roadmap for any subject?
It can structure many subjects, but the roadmap quality depends on accurate sources, realistic scope, prerequisite diagnosis and a clear learning outcome.
How long should a roadmap be?
Long enough to show dependencies and milestones, short enough to guide the next phase. A learner does not need every future detail on day one.
Should the roadmap have dates?
Use dates for real deadlines and approximate pacing. Let mastery evidence adjust the sequence.
How many resources should I use?
Usually one primary source plus targeted supplements is easier to manage than a large resource collection.
What if I already know some prerequisites?
Test briefly and remove them from the active roadmap if performance is stable.
What if I fall behind the roadmap?
Review whether the scope, weekly capacity, prerequisite assumptions or milestone difficulty were wrong. Adjust the roadmap rather than treating the calendar as failure.
How do I know when to move to the next milestone?
Use the exit test or transfer gate, not content completion alone.
What comes next?
The next learning articles move into finding knowledge gaps, generating practice questions, active recall and Socratic learning.
Helpful Reading
- How to Learn Anything Faster with Super Intelligence
- How to Build a Personal Super Intelligence Tutor
- How to Ask Super Intelligence to Explain Difficult Ideas at Different Levels
- How to Use Super Intelligence to Break Down Complicated Problems
Turn the Subject into a Route You Can Actually Travel
A new subject feels infinite before its structure is visible.
Define the destination. Limit the scope. Test prerequisites. Find the concepts that organise the field. Build skill corridors. Set output-based milestones. Integrate through projects. Test transfer. Review and update.
A learning roadmap becomes valuable when it tells you not only what exists in the subject, but what you should be able to do next and what evidence lets you move forward.