DEV Community

Aryan Vimal Ejantkar
Aryan Vimal Ejantkar

Posted on

SkillLens TutorKit: AI Worksheet & Teaching Pack Generator for Educators (Built with Gemma)

#hf26challenge #gemma #opensource #ai

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

What I Built

SkillLens TutorKit is an open-source, AI-powered worksheet and study pack generator designed specifically for independent tutors, private teachers, and small coaching centres.

Every week, educators spend between 5 to 12 hours manually drafting practice problems, cross-referencing answer keys, balancing difficulty tiers, and formatting study materials. For freelance tutors and boutique coaching academies who operate on thin margins and tight schedules, prep time is unpaid overhead.

SkillLens TutorKit automates this preparation workflow while keeping educators in full pedagogical control:

  1. Source Material Ingestion: Tutors provide chapter notes, textbook excerpts, or syllabus outlines (supporting PDF, DOCX, TXT, or direct text prompts).
  2. Pedagogical Structuring: The engine categorizes the subject (STEM, Humanities, Economics, etc.) and generates an aligned curriculum package.
  3. Multi-Format Question Generation:
    • Diagnostic and practice multiple-choice questions with verified pedagogical explanations for both correct and distractor answers.
    • Step-by-step worked exercises with revealable hints and mathematical equations formatted in KaTeX.
    • Spaced-retention interactive flashcards covering key definitions and formulas.
  4. Adaptive Socratic Assistant: A contextual tutor drawer that analyzes student misconceptions, offers progressive scaffolded hints, and generates targeted drill questions on demand.
  5. Private & Exportable Worksheets: Educators can review, edit, and export completed study sets into printable student-ready formats.

Demo

  • Live Demo: https://skilllens-ai.vercel.app (or run locally via http://127.0.0.1:5173)
  • *
  • Interactive Tour: The demo demonstrates the end-to-end workflow: uploading a chapter note on projectile motion, selecting "Intermediate" difficulty, automatically synthesizing a structured teaching set with KaTeX formulas, running the Socratic tutor drawer for step-by-step hints, and exporting the worksheet pack.

Code

The codebase is organized around a clean separation of concerns:

  • backend/app/: FastAPI application, Pydantic schemas, document extractors, and modular multi-provider AI routing.
  • frontend/: React 19 + Vite interface with KaTeX rendering, study workspace drawers, and interactive STEM simulation registries.

System Architecture 

graph TD
    A[Educator Source Material<br/>PDF, DOCX, TXT, or Prompt] --> B[Document Extractor Service]
    C[Curriculum Settings<br/>Subject, Level, Question Types] --> D[Universal Lesson & Worksheet Planner]
    B --> D
    D --> E{Multi-Provider AI Router}
    E -->|Cloud Inference| F[Gemma 4<br/>gemma-4-26b-a4b-it]
    E -->|Offline Local Inference| G[Ollama Gemma 2<br/>gemma2:9b]
    E -->|Multimodal Fallback| H[Gemini 2.5 Flash]
    F --> I[Pydantic Schema Validation]
    G --> I
    H --> I
    I --> J[React + Vite Frontend Engine]
    J --> K[Interactive Simulation Reg & KaTeX]
    J --> L[Socratic AI Tutor Drawer]
    J --> M[Exportable Study Set & Worksheet]

How I Built It

The technology stack was chosen for speed, offline reliability, and educational precision:

  • Frontend: React 19, Vite, and Vanilla CSS. Features dynamic KaTeX mathematical typesetting, responsive question review drawers, flashcard study modes, and interactive STEM visualization registries (projectile kinematics, calculus tangent trackers, and reaction mechanisms).
  • Backend API: Python 3.10+ and FastAPI, with modular route separation for lesson synthesis, tutor interaction, and provider health checks.
  • Models Tested & Integrated:
    • Google Gemma 4 (gemma-4-26b-a4b-it): Primary curriculum planning model invoked through the official google-genai SDK for lesson plans, multi-choice question generation, and Socratic tutoring.
    • Local Gemma 2 (gemma2:9b via Ollama): Offline inference provider running on localhost:11434, enabling 100% offline generation with zero network calls and zero token fees.
    • Gemini 2.5 Flash: Optional fallback provider for high-throughput multimodal inputs.
  • Structured Validation: Strict Pydantic models enforce schema contracts (LessonPlan, QuizItem, WorkedExample, VisualizationSpec). No unvalidated model output is rendered, and no executable code is injected into the client.
  • Document Ingestion: Extensible parsers for .pdf (using pypdf), .docx (using python-docx), and raw text with strict payload bounds.
  • Testing: Comprehensive 23-test automated test suite in pytest covering schema normalization, provider switching, tutor hint progression, and document extraction.

Current Implementation Status

Feature Status Notes
Universal Worksheet & Lesson Generation ✅ Working Full schema-validated output across 9 subject categories
Gemma 4 Cloud Inference ✅ Working Integrated via Google GenAI SDK (gemma-4-26b-a4b-it)
Offline Gemma Local Inference ✅ Working Zero-cloud offline mode via Ollama (gemma2:9b)
Document Text Extractor (PDF/DOCX/TXT) ✅ Working Safe multi-format document parser with size limits
KaTeX Math & Formula Typesetting ✅ Working Clean rendering for physics, calculus, and chemistry
Adaptive Socratic Tutor Drawer ✅ Working Contextual hints, misconception diagnosis, dynamic practice
Exportable Study Sets ✅ Working Client-side export of study materials and raw text
Automated Direct PDF Print Layout 🔄 In Progress ReportLab integration for two-column printable school worksheets

Why Does Open Innovation Matter?

For an educational application built as a sustainable side hustle, open innovation is essential to the core value proposition:

1. Data Privacy for Proprietary Teaching Notes

Educators and coaching centres frequently work with proprietary question banks, unpublished mock tests, and student assessment data. When using closed cloud APIs, every prompt and document is transmitted to external servers. With open-weight models like Gemma running locally via Ollama, student materials never leave the tutor's laptop.

2. Eliminating Variable Per-Token Overhead

Commercial SaaS APIs charge per thousand tokens. For an independent tutor generating 40 to 60 customized drill sheets a week, per-token billing creates unpredictable variable costs that eat into hourly margins. An open-weight model transforms AI from a recurring meter into a zero-marginal-cost desktop tool.

3. Model Independence & No Vendor Lock-In

By building a pluggable provider interface, SkillLens TutorKit is not held hostage by external pricing changes, deprecation cycles, or sudden API rate limits. Educators can seamlessly switch between cloud Gemma 4 and local Gemma 2 depending on their hardware and connectivity.

4. Inspectability & Pedagogical Customization

Closed AI models are black boxes. Open architectures let the community inspect prompt strategies, validate pedagogical constraints, fine-tune models on specific national syllabi, and guarantee deterministic outputs.

My Agent Session

This project was built and audited using an autonomous AI pair-programmer session with DevRelay. You can inspect the complete build log, prompt engineering, and test runs below:

Building SkillLens TutorKit with Gemma and FastAPI
You

Auditing SkillLens TutorKit for Hacktoberfest Week 2: Side Hustle and verifying Gemma models.

Agent

Audited workspace, added MIT License, verified 23 pytest unit tests passing, configured Gemma 4 and Ollama Gemma 2 pipelines.

2 of 2 messages

🔗 View Session on DEV

My First User

To ground TutorKit in real educational needs, I shared the prototype with a high-school mathematics and physics tutor who manages four coaching batches (approx. 25 students).

The Workflow Test:
The educator uploaded raw lecture notes on Kinematics and Projectile Motion and asked TutorKit to generate an intermediate-level problem set with worked solutions and multiple-choice questions.

Findings & Feedback:

  • Time Saved: Generating a balanced 10-question practice set with comprehensive step-by-step explanations took under 3 minutes, compared to their typical 90–120 minutes of manual typing and solution verification.
  • Answer Key Accuracy: The tutor highlighted that having detailed pedagogical explanations for why an incorrect option is wrong was the single most valuable feature, as writing distractor explanations manually is the most time-consuming part of worksheet prep.
  • Willingness to Pay: The tutor stated they would gladly pay $19 to $29 per month (or a one-time license of $79) for an offline desktop version with automated PDF export, as it saves them at least 6 to 8 hours of unpaid prep work each week.

Prize Categories

Featured Category: Best Use of Gemma

SkillLens TutorKit is engineered around the Gemma open-model ecosystem:

  • Google Gemma 4 (gemma-4-26b-a4b-it): Powers rich curriculum generation, structured multi-tier questions, and the adaptive Socratic tutor through the Google GenAI SDK.
  • Local Gemma 2 (gemma2:9b via Ollama): Powers complete offline, private worksheet generation on local hardware with zero API keys and zero network dependency.

🌐 Community Wisdom

Developing local-first educational tools requires balancing latency, structured output compliance, and hardware constraints. DEV community builders have documented key patterns for open-weight models in education:

🌐 Community Wisdom: My mom spends hours every week making test papers. I built her a generator that runs offline on Gemma 4

Source: notnirav

Tags: devchallenge, weekendchallenge, hf26challenge, gemma

Highlighting that independent educators are overwhelmed by weekly test paper preparation, and that running Gemma offline provides both zero-cost operating economics and reliable structured output when paired with strict Pydantic parsing.

🔗 Read Full Discussion

🌐 Community Wisdom: Building a local-first AI tutor for my daughter (and 10–14 year-olds in Austrian schools) with Gemma 4

Source: georgpiwonka

Tags: devchallenge, gemmachallenge, gemma, dotnet

Proves that educational deployments in schools demand strict data privacy and pedagogical scaffolding, where open-weight models grant developers full control over hint pacing and data protection.

🔗 Read Full Discussion

Summary

SkillLens TutorKit proves that open-weight AI can be transformed into a practical, revenue-generating tool for independent educators. By combining local and cloud Gemma models with strict schema validation and interactive learning components, TutorKit turns hours of tedious worksheet preparation into minutes of effortless curation.

Top comments (0)