Wayfinder GED — Module Architecture

Module design: four subjects, assignment generation, progress tracking, metric recording, success criteria. Start here before using any other GED page.

PurposeDefines how the GED module is structured — the four subjects, how assignments get generated, how progress gets tracked.

StatusActive Development — real, complete pedagogical content; not yet run with real students

Depends onWayfinder Protocol Bank

Superseded by—

EvidenceFull document reproduced below, unedited from source.

GED MODULE ARCHITECTURE

Four Subjects, Learning-Focused Structure, Persistent Progress Tracking

Status: Foundation artifact for GED module
Date: June 2026
Scope: Mathematical Reasoning, Reasoning Through Language Arts, Science, Social Studies
Design principle: No teacher/tutor bias. Record what works, what doesn’t, what the system learns.

PART 1: GED SUBJECT STRUCTURE (4 Subjects, Main Sections)

Subject 1: Mathematical Reasoning

Main sections: 1. Number & Operations — Place value, integers, decimals, fractions, percents, ratios, proportions 2. Algebra & Functions — Expressions, equations, inequalities, quadratic functions, linear functions, graphing 3. Geometry & Measurement — Area, volume, perimeter, angles, coordinate plane, transformations, trigonometry basics 4. Data & Statistics — Mean/median/mode, probability, data interpretation, experimental design basics

Each section contains: - Concept definitions (no bias toward how to teach, just what needs to be learned) - Diagnostic probes (questions that identify where breakdown occurs) - Common misconceptions (errors observed in student work) - Prerequisite skills (what must be solid first) - Worked examples (all with Python sandbox verification) - Practice assignment templates (generated per student, tracked per attempt)

Subject 2: Reasoning Through Language Arts (RLA)

Main sections: 1. Reading Comprehension — Main idea, supporting details, inference, author’s purpose, text structure 2. Argument & Evidence — Claims, evidence quality, counterarguments, logical fallacies, rhetorical strategies 3. Grammar & Usage — Sentence structure, verb tense, pronoun agreement, punctuation, mechanics 4. Writing — Organization, thesis development, paragraph structure, revision, Extended Response essay structure

Each section contains: - Concept definitions - Diagnostic probes - Common misconceptions - Prerequisite skills - Text-based examples (from actual GED-level passages) - Practice assignment templates (written, tracked, scored)

Subject 3: Science

Main sections: 1. Life Science — Cell structure/function, genetics, evolution, ecology, human body systems 2. Physical Science — Motion/forces, energy, waves, atoms/matter, chemistry basics 3. Earth & Space Science — Geology, weather/climate, astronomy, Earth systems 4. Science Practices — Experimental design, data interpretation, hypothesis testing, scientific reasoning

Each section contains: - Concept definitions - Diagnostic probes - Common misconceptions - Prerequisite skills - Scenario-based examples - Practice assignment templates (multiple format: multiple choice, short answer, analysis)

Main sections: 1. U.S. History — Colonial period through present, major events, documents, constitutional development 2. Civics & Government — Constitution, branches, rights, voting, state/federal systems, political processes 3. Economics — Supply/demand, markets, trade, personal finance, macroeconomics basics 4. Geography & Global Context — Map skills, regions, cultures, global systems, human geography

Each section contains: - Concept definitions - Diagnostic probes - Common misconceptions - Prerequisite skills - Historical documents/examples - Practice assignment templates (analysis, interpretation, application)

PART 2: ASSIGNMENT GENERATION SYSTEM

How Assignments Are Created

Input data: - Student’s current profile (which concepts are solid, which have gaps) - Target concept (what needs practice) - Difficulty tier (based on student’s performance history) - Format preference (multiple choice, short answer, written response, analysis, math problem)

Output: - Single assignment — tailored to student’s gap + current skill level + preferred format - Embedded tracking — assignment ID, timestamp, attempt number, format, difficulty - Sandbox verification — for math/logic, Python code runs the correct answer - Scoring mechanism — automated for multiple choice, structured rubric for open-ended

Assignment templates by subject:

Math assignments:

Format: Multi-part problem set
- 3-5 problems at student's working level
- Each problem has Python sandbox verification
- Answer options auto-generated (correct answer + 3 plausible distractors)
- Timeout for completion (suggest, not enforce)
- Scoring: accuracy + time

RLA reading assignments:

Format: Passage + comprehension questions
- 300-500 word passage at student's level
- 4-6 comprehension questions (mix of recall, inference, analysis)
- Scoring: accuracy only (no time pressure for reading)
- Follow-up: if <70% accuracy, diagnostic to identify reading gap

RLA writing assignments:

Format: Prompt + essay response
- Single extended response prompt (like GED Extended Response)
- Rubric: thesis clarity, evidence quality, organization, grammar
- Scoring: structured rubric (0-3 per dimension)
- AI analysis: what worked, what broke down

Science assignments:

Format: Scenario + analysis questions
- Real-world scenario or experimental setup
- 4-6 analysis questions (explain, predict, evaluate, design)
- Scoring: accuracy + reasoning quality
- Misconception check: does response show common conceptual error?

Social Studies assignments:

Format: Document/scenario + analysis
- Primary source or contemporary scenario
- 4-6 analysis questions (interpret, compare, apply, evaluate)
- Scoring: accuracy + reasoning quality
- Context check: does student understand larger context?

PART 3: PROGRESS TRACKING APPS (Persistent Memory)

These apps live in Claude artifacts. They track: - Student metrics (what the student did, how well, trends) - AI metrics (what assignments worked, which were too hard/easy, what improved performance)

App 1: Assignment Tracker

Records every assignment attempt:

ASSIGNMENT_RECORD:
├─ assignment_id: unique ID
├─ date_assigned: timestamp
├─ subject: (Math / RLA / Science / Social Studies)
├─ section: (specific content area)
├─ target_concept: (what skill was being practiced)
├─ difficulty_tier: (1-5 scale)
├─ format: (multiple choice / short answer / written / analysis)
├─ time_allocated: (minutes suggested)
├─ completion_date: (when student completed)
├─ time_taken: (actual minutes)
├─ accuracy: (% correct or rubric score)
├─ student_reasoning: (notes from student on how they approached it)
├─ misconceptions_detected: (list of errors from assignment)
├─ next_target: (what to work on next based on performance)
└─ ai_notes: (what the system learned from this assignment)

App 2: Concept Mastery Tracker

Tracks progress per concept across multiple assignments:

CONCEPT_RECORD:
├─ concept_id: unique ID
├─ concept_name: (e.g., "Linear Equations")
├─ subject: (Math / RLA / Science / Social Studies)
├─ section: (specific area within subject)
├─ first_assigned: (date first practice)
├─ assignments_completed: (count)
├─ accuracy_trend: [attempt1_score, attempt2_score, ..., attempt_n_score]
├─ average_accuracy: (% across all attempts)
├─ mastery_status: (not_started / developing / proficient / mastered)
├─ mastery_criteria: (what counts as mastered for this concept)
├─ prerequisite_concepts: (what must be solid first)
├─ commonly_missed_elements: (what part of this concept trips students up)
├─ next_action: (continue practicing / move to next level / re-teach prerequisite)
└─ ai_assessment: (is student ready to move on?)

App 3: Monthly Performance Report

Generated monthly, records BOTH student and AI performance:

MONTHLY_REPORT:
├─ month: (June 2026, etc.)
├─ student_summary:
│  ├─ assignments_completed: (count by subject)
│  ├─ average_accuracy: (by subject)
│  ├─ concepts_mastered: (count)
│  ├─ concepts_developing: (count)
│  ├─ time_invested: (total hours)
│  ├─ participation_pattern: (frequency, consistency)
│  └─ confidence_observations: (does student seem more confident?)
│
├─ ai_performance_summary:
│  ├─ assignment_effectiveness: (which assignments led to learning?)
│  ├─ difficulty_calibration: (were assignments too easy/hard?)
│  ├─ misconception_detection_rate: (how many errors did system catch?)
│  ├─ concept_sequencing: (did order of concepts make sense?)
│  ├─ gap_identification_accuracy: (did system identify real gaps?)
│  └─ improvement_areas: (where should we adjust system?)
│
├─ system_metrics:
│  ├─ average_time_per_assignment: (minutes)
│  ├─ assignment_completion_rate: (%)
│  ├─ conceptual_error_rate: (how many misconceptions per assignment)
│  ├─ prerequisite_gap_frequency: (how often student lacked prerequisite skill)
│  └─ reassignment_frequency: (how many times did we re-teach something)
│
└─ next_month_adjustments:
   ├─ concept_priority: (what to focus on)
   ├─ difficulty_settings: (adjust tier up/down?)
   ├─ assignment_format_adjustments: (which formats work best?)
   └─ ai_system_improvements: (what needs tuning)

PART 4: METRIC RECORDING (What Gets Measured)

Student Metrics (per assignment)

Accuracy: % correct (math, MC questions) or rubric score (open-ended)
Completion time: Minutes from start to finish
Attempt history: How many tries before correct
Error patterns: Which types of errors occurred
Reasoning quality: Did student explain their thinking?
Misconception flags: Which common mistakes appeared?

Student Metrics (monthly)

Progress trend: Is accuracy improving over time?
Concept retention: Can student re-do earlier concepts without reteaching?
Breadth vs. depth: How many concepts started vs. mastered?
Engagement pattern: Consistent practice or sporadic?
Transfer ability: Can student apply concept in new context?

AI Metrics (per assignment)

Difficulty calibration: Was this assignment right difficulty level?
Prerequisite accuracy: Did student have the skills needed?
Learning outcome: Did this assignment lead to improvement on next attempt?
Misconception detection: Did the system identify what went wrong?
Format effectiveness: Did this assignment format work for this student?

AI Metrics (monthly)

Assignment effectiveness score: Which assignments best predicted learning?
Concept sequencing quality: Did teaching concepts in this order make sense?
Difficulty adjustment accuracy: How often did we get difficulty right?
Gap prediction accuracy: When we predicted a gap, was it real?
Misconception inventory accuracy: Are our common misconceptions actually common?

PART 5: LESSON PROMPT TEMPLATE (No Pedagogical Bias)

When student needs explanation/instruction (not assignment), system uses this:

Input to prompt: - Concept being taught - Student’s current understanding (from prior assignments/diagnostic) - Student’s learning style preference (visual/analytical/step-by-step) - Context if available (real-world application they care about)

Output structure: 1. Define the concept — clear, unambiguous definition 2. Show the mechanism — how/why this concept works 3. Worked example — step-by-step walkthrough (math: show all steps in Python sandbox) 4. Check understanding — question to test whether explanation landed 5. Next step — what to practice next

What it is NOT: - No motivational framing (“This is important because…”) - No teaching tricks or pedagogical scaffolding - No metaphors or analogies (unless student asks) - Just: here’s what you need to know, here’s how it works, here’s what to do next

PART 6: SOCRATIC DISCUSSION PROMPT TEMPLATE (Pure Questioning)

When student has a gap or misconception, instead of explaining, use questions:

Input: - What the student got wrong - What the correct answer is - What reasoning would lead to correct answer

Question structure (no leading): 1. Clarification: “What did you think the problem was asking?” 2. Reasoning check: “Walk me through how you got that answer” 3. Edge case: “What if [change one condition]? What would happen?” 4. Contrast: “How is this different from [related problem you got right]?” 5. Rebuild: “What information do you have? What do you need to find?”

Constraint: Only ask questions. Don’t answer. Don’t explain. Let student think.

PART 7: SANDBOX MATH PROTOCOL

All math assignments use Python sandbox for verification:

# VERIFIED_ANSWER template
def verify_problem(student_answer, problem_params):
    """
    Every math problem includes:
    1. Problem statement
    2. Student's answer
    3. Python code that computes correct answer
    4. Comparison (student_answer == correct_answer)
    5. Work shown (so student can see where they went wrong)
    """
    
    correct_answer = compute_correct_answer(problem_params)
    is_correct = student_answer == correct_answer
    
    if not is_correct:
        work_shown = show_step_by_step_solution(problem_params)
        return {
            'correct': False,
            'student_answer': student_answer,
            'correct_answer': correct_answer,
            'work': work_shown,
            'misconception_detected': identify_error_pattern(student_answer, correct_answer, problem_params)
        }
    else:
        return {'correct': True, 'student_answer': student_answer}

PART 8: ASSIGNMENT GENERATION LOGIC (Pseudocode)

GENERATE_ASSIGNMENT(student_profile, target_concept, difficulty_tier):

1. GET current_accuracy ON target_concept
   IF current_accuracy >= 90%:
      → Move to next concept (student mastered this)
   IF current_accuracy 70-89%:
      → Generate assignment at same tier, different format
   IF current_accuracy < 70%:
      → Check if prerequisite_concepts are solid
         IF prerequisite gap detected:
            → Assignment on prerequisite, then return here
         ELSE:
            → Generate assignment at lower tier, same concept

2. SELECT assignment_format (rotate through formats, don't repeat last)

3. GENERATE assignment (tailored to student profile)

4. IF math_subject:
      → Create Python sandbox verification
      → Generate answer options (correct + 3 plausible distractors)

5. IF text_subject:
      → Create structured rubric
      → Prepare grading criteria

6. RECORD assignment in tracking system with metadata

7. RETURN assignment to student

PART 9: UPDATING STUDENT PROFILE (After Each Assignment)

UPDATE_PROFILE(assignment_result):

1. RECORD assignment result (accuracy, time, format, concept)

2. UPDATE concept_mastery_tracker:
   - Add accuracy score to trend
   - Recalculate average_accuracy
   - Check mastery_criteria (is concept mastered now?)
   - Update mastery_status

3. DETECT misconceptions:
   - If error pattern matches known misconception → flag it
   - If novel error pattern → add to misconception_inventory

4. CHECK prerequisites:
   - If student failed but prerequisite not tested → test prerequisite next
   - If prerequisite is weak → build prerequisite next

5. ADJUST difficulty_tier:
   - If accuracy > 90% → increase tier
   - If accuracy < 60% → decrease tier
   - Stay same tier if 60-90%

6. PREDICT next_assignment:
   - If concept mastered → move to next concept
   - If concept developing → same concept, different format
   - If prerequisite gap detected → teach prerequisite

7. UPDATE monthly_report (if month boundary crossed)

PART 10: SUCCESS CRITERIA BY SUBJECT

Math assignments: - Accuracy ≥ 85% on 2 consecutive assignments = concept proficient - Student can explain reasoning = concept mastered - Can apply to new problem type = concept transferred

RLA reading assignments: - Accuracy ≥ 80% on comprehension questions = reading skill solid - Can infer main idea from unstated text = inferential reading works - Can evaluate author’s purpose = critical reading works

RLA writing assignments: - Thesis clearly stated = 25% of mastery - Evidence supports thesis = 25% of mastery - Organization clear = 25% of mastery - Grammar/mechanics acceptable = 25% of mastery - All four met = concept mastered

Science assignments: - Accuracy ≥ 85% on knowledge questions = content solid - Can explain reasoning = conceptual understanding works - Can predict outcome of new scenario = transfer works

Social Studies assignments: - Accuracy ≥ 80% on comprehension = can understand content - Can compare/contrast concepts = analytical thinking works - Can apply to new context = transfer works

PART 11: WHEN TO ESCALATE (What Triggers Different Approach)

RED FLAGS that trigger deeper investigation: 1. Same misconception appears >3 times despite correction 2. Student accuracy on concept drops after initial mastery 3. Student accuracy on concept A drops when studying related concept B (indicates misunderstanding) 4. Student can answer multiple choice but fails open-ended on same concept 5. Time per assignment increasing (indicator of struggle) 6. Student reports confusion despite high accuracy (misalignment)

YELLOW FLAGS that trigger adjustment: 1. Accuracy plateau at 65-75% (stuck in “developing” stage) 2. Consistent errors only in final step of multi-step problem 3. Student gets multiple-choice wrong but explains correct reasoning 4. Difficulty tier repeatedly adjusted (system can’t calibrate) 5. Prerequisite gap discovered late (should have been caught earlier)

RESPONSE PROTOCOL: 1. Drop back to diagnostic (what’s the actual gap?) 2. Separate concept into smaller pieces 3. Change assignment format 4. Slow down progression 5. Rebuild prerequisite if needed

End of GED Module Architecture

This is the foundation. Each subject gets detailed curriculum maps next. Each section gets diagnostic probes, common misconceptions, and assignment templates.

No teacher/tutor bias. Pure learning architecture. Record what works and what doesn’t.