LinuxMentor

Learn Linux by doing, one command at a time.

LinuxMentor is an agentic Linux tutoring product for complete beginners through intermediate users who want to become productive in terminal, server, and cloud environments. It teaches through short explanations, live terminal challenges, quizzes, debugging help, and guided projects, adapting difficulty based on performance and mistakes.

Business Goals

  • Reach 25,000 registered learners within 6 months of launch.
  • Convert at least 8% of free users to a paid plan within 90 days of signup.
  • Achieve 35% weekly active user retention by month 3.
  • Keep lesson completion rate above 60% for first-time learners in the first 30 days.
  • Reduce support escalations by 40% through self-serve debugging and command explanations.

User Goals

  • Help beginners confidently use the Linux terminal within their first week.
  • Enable users to complete practical tasks like file management, permissions, and process inspection without memorizing commands blindly.
  • Build competence in Bash scripting, networking, and system administration through guided practice.
  • Prepare learners to work in AI and data science Linux environments using Python, Git, virtual environments, and Docker.
  • Give users personalized feedback on mistakes so they can improve faster.

Non-Goals

  • Not a full general-purpose AI chat assistant for non-Linux topics.
  • Not a production remote desktop or cloud workstation manager.
  • Not a complete certification exam prep platform at launch.
  • Not a replacement for a real Linux shell; practice should be guided and optionally simulated in safe labs.

Beginner Ben, 22 - A university student who has used only Windows and is intimidated by the terminal. He wants to learn Linux for coursework, internships, and eventually data science work.

Beginner Ben, 22

  • As a beginner, I want short explanations with examples, so that I can understand commands without getting overwhelmed.
  • As a learner, I want terminal challenges with instant feedback, so that I can practice safely and correct mistakes quickly.
  • As a student, I want a roadmap that shows what I have completed, so that I can see progress and stay motivated.

Career Switcher Amina, 31 - A data analyst moving into machine learning who needs Linux, Python, Git, and environment setup skills. She learns best when tasks are realistic and tied to work outcomes.

Career Switcher Amina, 31

  • As a career switcher, I want Linux lessons connected to AI and data science workflows, so that I can use the skills on real projects.
  • As a learner, I want debugging help that explains errors in plain language, so that I can troubleshoot on my own later.
  • As a busy professional, I want lessons that take 10 to 15 minutes, so that I can make progress consistently.

Junior Dev Luis, 26 - A junior software developer who knows basic terminal commands but struggles with permissions, services, SSH, and shell scripts on servers.

Junior Dev Luis, 26

  • As a developer, I want advanced challenges after I pass quizzes, so that I keep improving instead of repeating easy tasks.
  • As a user, I want Bash scripting exercises with validation, so that I can automate repetitive work confidently.
  • As a server user, I want practice with logs, systemd, and networking, so that I can troubleshoot Linux systems professionally.

Adaptive Learning Engine · High priority

  • Personalize lessons, difficulty, and review based on user performance, errors, and completion history.
  • Track a skill score from 0 to 100 and update it after quizzes and terminal tasks.
  • Store completed topics, weak areas, repeated command confusion, and project history.
  • Escalate difficulty after correct answers and slow down with simpler examples after repeated mistakes.
  • Recommend review lessons when a topic has not been practiced recently.
  • Support lesson sequencing by roadmap level and mastery gates.

Interactive Lesson Delivery · High priority

  • Deliver one concept at a time using the explain, demonstrate, task, check, correct, increase difficulty loop.
  • Present concise explanations before practice.
  • Show example commands only when appropriate for the current step.
  • Ask the learner to type commands or predict outputs before revealing answers.
  • Support lesson modes such as lesson, practice, quiz, debug, project, and review.
  • Generate daily lessons with objective, commands, examples, practice, quiz, homework, and progress update.

Terminal Challenge Workspace · High priority

  • Provide safe, realistic terminal practice in a sandboxed environment or simulated shell.
  • Use a safe default workspace such as /home/student/linux-lab.
  • Prevent destructive commands from affecting the host system.
  • Allow commands like mkdir, touch, cp, mv, cat, grep, find, chmod in a sandbox.
  • Validate user input by checking command syntax, intent, and resulting state.
  • Return actionable feedback with corrected commands and a similar follow-up challenge.

Debugging Assistant · Medium priority

  • Help users interpret Linux errors and diagnose problems systematically.
  • Use the pattern error, meaning, possible causes, diagnostic command, fix, prevention.
  • Recognize common errors like permission denied, command not found, no such file or directory, and service failures.
  • Suggest safe diagnostics before fixes.
  • Explain when elevated permissions or safer alternatives are needed.
  • Preserve the user’s context so follow-up debugging continues from the same issue.

Progress and Assessment · Medium priority

  • Provide structured assessment through quizzes, exams, and project completion tracking.
  • Support multiple-choice, fill-in-the-command, scenario, and terminal challenge quizzes.
  • Score responses and show explanations after the user answers.
  • Offer periodic roadmap summaries and weakness reports.
  • Unlock projects after major level milestones.
  • Keep a history of questions answered, scores, and topics mastered.

First-Time Skill Assessment

  • Greet the learner and explain that the product teaches Linux by doing, not by memorizing.
  • Ask 10 short questions covering terminal basics, filesystem, permissions, processes, networking, and Bash.
  • Do not reveal answers until the learner responds.
  • Score responses and estimate skill from 0 to 100.
  • Show starting level, weak areas, and a personalized learning path.
  • Start Lesson 1 immediately with a small, manageable concept and a practice task.

1. Assess

  • The user starts with a short diagnostic to establish baseline knowledge.
  • Mix multiple choice, command recall, and scenario questions.
  • Avoid advanced topics if the user misses fundamentals.
  • Persist the results to seed the roadmap.

2. Explain

  • Present a short, plain-language explanation of one concept.
  • Use the format what it is, why it matters, command, example, practice, real-world use.
  • Keep theory brief and practical.
  • Define terms like shell, path, PID, and permission only when relevant.

3. Demonstrate

  • Show a command or workflow in a realistic context.
  • Use a sample terminal session or snippet.
  • Highlight the parts that matter and common mistakes.
  • Include safety notes for risky commands.

4. Practice

  • Ask the learner to complete a terminal task or answer a quiz question.
  • Wait for user input before showing the solution.
  • Accept equivalent commands when valid.
  • Provide immediate correction and explanation if the answer is incomplete or wrong.

5. Review and Advance

  • Update mastery, identify weak areas, and propose the next harder challenge.
  • Increase difficulty after correct answers.
  • Schedule targeted practice for errors.
  • Show progress toward the next milestone or project.

Power User Learning Tools

  • Hard Mode with multi-step real-world scenarios.
  • Project mode for system-monitoring, backup automation, and Linux AI environment setup.
  • Custom review sessions for weak commands and concepts.
  • Command explanation mode for pasted shell output or error messages.
  • Roadmap view across all 8 learning levels with mastery indicators.

Learning-Centered Interface

  • Split layout with lesson content and a terminal-style practice pane.
  • Clear visual distinction between explanation, challenge, answer, and correction states.
  • Accessible typography, high contrast, and keyboard-first navigation.
  • Fast response time for command checks to keep the practice loop engaging.
  • Progress indicators for skill score, mastered topics, and current level.

Ben has never used Linux before, and the terminal feels intimidating. On day one, LinuxMentor asks ten short questions, identifies that Ben knows almost nothing about paths or commands, and starts him with pwd, ls, and cd in a safe lab environment.

After a few lessons, Ben can create folders, inspect files, and fix simple mistakes without guessing. When he enters the wrong command, LinuxMentor explains what happened, shows the corrected version, and gives him a similar challenge so the lesson sticks.

A few weeks later, Ben is comfortably working through permissions, processes, and Bash scripts. He is now able to set up a Linux workspace for Python and Git, which makes him more effective for coursework and his first data science internship.

User-Centric Metrics

  • 70% of new users complete the first lesson within 15 minutes.
  • 60% of learners finish at least 3 lessons in their first week.
  • Average quiz accuracy reaches 80% by the end of Level 2.
  • At least 50% of users successfully complete one terminal challenge per session.
  • User-reported confidence in Linux increases by 2 points on a 5-point scale within 30 days.

Business Metrics

  • 25,000 registered users within 6 months.
  • 8% free-to-paid conversion within 90 days.
  • 35% weekly retention by month 3.
  • 20% month-over-month growth in active learners during the first 2 quarters.
  • Less than 5% of support tickets require manual intervention for common Linux questions.

Technical Metrics

  • 99.9% uptime for the learning experience.
  • Median lesson response latency under 1.5 seconds.
  • Sandbox command validation completes in under 500 milliseconds for standard tasks.
  • Zero host-system impact from sandboxed terminal practice.

Tracking Plan

  • assessment_started
  • assessment_completed
  • lesson_started
  • lesson_completed
  • terminal_challenge_submitted
  • terminal_challenge_passed
  • quiz_answer_submitted
  • debug_session_started
  • project_completed
  • weak_area_flagged

Technical Needs

  • Web app built with Next.js and TypeScript.
  • Backend API with Node.js or Python FastAPI for lesson orchestration and scoring.
  • PostgreSQL for user profiles, progress, lesson history, and mastery state.
  • Redis or similar cache for session state, pacing, and short-lived challenge data.
  • Sandbox execution layer using containers or isolated VMs for terminal practice.
  • Object storage for lesson assets, logs, and generated examples.
  • Authentication and session management with secure token handling.

Integration Points

  • OAuth login with Google and GitHub.
  • OpenAI or compatible LLM API for explanation, quiz generation, and feedback.
  • Docker or Kubernetes for sandbox isolation and environment provisioning.
  • Analytics platform such as PostHog or Amplitude.
  • Email or in-app notifications for lesson reminders and progress summaries.

Data Storage & Privacy

  • Store only the minimum personal data needed for account and progress tracking.
  • Separate user identity data from learning history where possible.
  • Encrypt sensitive data in transit and at rest.
  • Provide export and deletion workflows aligned with GDPR and CCPA expectations.
  • Avoid storing raw terminal commands that contain secrets unless explicitly redacted.

Scalability & Performance

  • Scale lesson generation and command validation separately from the main app.
  • Cache repeated explanations and static lesson content.
  • Use queue-based processing for long-running tasks like project checks or sandbox provisioning.
  • Monitor LLM cost and response times with rate limits and fallback responses.

Potential Challenges

  • Users may copy commands without understanding them; mitigate with one-step explanations and answer checks.
  • Destructive command safety is critical; mitigate with sandboxing, command allowlists, and warnings for risky actions.
  • LLM output may be inconsistent; mitigate with templated lesson structures and validation rules.
  • Beginners may feel overwhelmed by too much content; mitigate with short lessons and adaptive pacing.
  • Terminal simulation may differ from real Linux behavior; mitigate with realistic environments and clear labeling when simulations are used.

Team & resourcing - Small team - 2 engineers, 1 product designer, part-time PM, and access to a DevOps advisor.

Phase 1: MVP Assessment and Lesson Engine · Weeks 1–4

  • 10-question onboarding assessment
  • User skill scoring and roadmap generation
  • Lesson template with explain, demonstrate, practice, check loop
  • Basic progress tracking and weak-area storage
  • Initial Level 1 content for terminal basics

Phase 2: Safe Terminal Practice · Weeks 5–8

  • Sandboxed practice workspace
  • Challenge validator for file and directory commands
  • Quiz modes for multiple choice and fill-in-the-command
  • Correction feedback and follow-up challenge generation
  • Safety guardrails for destructive command categories

Phase 3: Adaptive Tutor and Debugging · Weeks 9–12

  • Adaptive difficulty logic
  • Debug mode for Linux error diagnosis
  • Expanded coverage for permissions, processes, and networking
  • Roadmap review and weekly progress summaries
  • Analytics instrumentation for learning funnel and retention

Phase 4: Projects and AI Workflow Tracks · Weeks 13–16

  • Beginner, intermediate, and advanced project modes
  • Linux for AI and Data Science lessons
  • Python venv, Git, Jupyter, and Docker workflow modules
  • Hard Mode scenarios and exam mode
  • Polished onboarding and retention loops

Paste this into Cursor, Bolt, Lovable, or v0 to start building.

Build a web app called LinuxMentor, an agentic Linux learning assistant for beginners through intermediate users.

Product goal:
Teach Linux step-by-step using an explain, demonstrate, practice, check, correct, increase-difficulty loop. The app must support an initial 10-question assessment, a personalized roadmap, adaptive lesson difficulty, terminal challenges, quizzes, debugging help, projects, and progress tracking.

Core screens and flows:
1. Onboarding assessment with 10 short questions and skill scoring from 0 to 100.
2. Personalized dashboard showing current skill level, completed topics, weak areas, and next lesson.
3. Lesson screen with short explanation, example commands, a practice task, answer submission, feedback, and next-step recommendations.
4. Terminal challenge screen with a safe sandbox workspace such as /home/student/linux-lab, command input, validation, and corrected feedback.
5. Quiz and debug modes for multiple choice, command fill-in, and Linux error diagnosis.
6. Project mode for beginner, intermediate, and advanced Linux projects.
7. Roadmap and review screens showing progress across Linux fundamentals, files, permissions, processes, networking, Bash, advanced Linux, and Linux for AI/data science.

Behavior requirements:
Persist skill score, completed topics, weak areas, learning history, quiz scores, and command confusion patterns per user.
Support mode commands such as START, PRACTICE, QUIZ, DEBUG, PROJECT, REVIEW, ROADMAP, WEAKNESS, EXPLAIN, CHEATSHEET, EXAM, and HARD MODE.
Do not reveal solutions before the user responds. Validate answers and provide concise corrections.
Use a safety layer that warns about risky commands like rm, chmod, chown, dd, mkfs, fdisk, iptables, and systemctl, and route destructive practice into a safe simulation.

Suggested tech stack:
Frontend: Next.js, React, TypeScript, Tailwind CSS.
Backend: FastAPI or Node.js with a REST API.
Database: PostgreSQL.
Cache/session state: Redis.
Sandbox execution: Docker-based isolated command runner or lightweight VM sandbox.
Auth: Google and GitHub OAuth.
Analytics: PostHog or Amplitude.
AI: OpenAI-compatible API for tutoring, feedback, and lesson generation.

Data model entities:
User, Assessment, SkillProfile, Lesson, LessonStep, PracticeAttempt, QuizAttempt, CommandHistory, WeakArea, Project, Completion, FeedbackEvent, LearningSession.
Include timestamps, mastery state, difficulty score, and explanation text fields.

Implementation priorities:
Ship MVP first with assessment, lesson engine, progress tracking, and basic Level 1 content.
Then add safe terminal practice, quiz modes, debugging, adaptive tutoring, and finally project mode and AI workflow lessons.
Ensure the UI is beginner-friendly, fast, accessible, and optimized for hands-on learning.
Build it as a production-ready SaaS with clear separation between lesson content, AI orchestration, and sandbox execution.

Business Idea

🐧 LinuxMentor AI — Agentic Linux Learning Assistant You are LinuxMentor AI, an intelligent, interactive, agentic AI tutor whose job is to take me from complete Linux beginner to advanced Linux user through practical, hands-on learning. 🎯 Main Goal Teach me Linux step-by-step until I can confidently: - Use the Linux terminal - Manage files and directories - Understand Linux permissions and ownership - Install and manage software - Manage users and groups - Monitor processes and system resources - Use networking commands - Write Bash scripts - Manage services with systemd - Understand SSH - Work with Git and development environments - Troubleshoot Linux systems - Understand Linux security fundamentals - Use Linux for AI/Data Science development - Eventually work comfortably with servers and cloud Linux environments --- 🧠 TEACHING STYLE Assume I am starting from zero. Do NOT dump huge amounts of theory. Use this learning cycle: Explain → Demonstrate → Give me a task → Check my answer → Correct me → Increase difficulty Explain difficult concepts using simple language and practical examples. Whenever possible, explain: «What it is → Why it matters → Command → Example → Practice → Real-world use» Use short explanations first. Give deeper explanations when I ask. --- 🗺️ LEARNING ROADMAP Teach me through these levels. LEVEL 1 — Linux Fundamentals Teach: - What Linux is - Linux distributions - Ubuntu - Kernel vs operating system - Terminal - Shell - Bash - CLI vs GUI - Linux filesystem - "/" - "/home" - "/etc" - "/var" - "/usr" - "/tmp" - "/bin" - "/sbin" - "/opt" Practice commands: pwd ls cd mkdir touch cp mv rm cat less head tail clear history --- LEVEL 2 — Files & Directories Teach: - Absolute paths - Relative paths - Hidden files - Wildcards - File types - Searching files - File compression Commands: find locate grep tar gzip zip unzip du df tree Give me realistic terminal challenges. --- LEVEL 3 — Permissions & Users Teach: - Users - Groups - Ownership - Read/write/execute permissions - Numeric permissions - "chmod" - "chown" - "chgrp" - "sudo" - "/etc/passwd" - "/etc/group" Practice examples such as: «"Give the owner read/write permission and everyone else read-only permission."» Then make me solve it. --- LEVEL 4 — Processes & System Management Teach: ps top htop kill pkill jobs bg fg free uptime uname systemctl journalctl Teach: - Processes - PID - Background processes - Signals - Services - systemd - Logs - CPU/RAM monitoring --- LEVEL 5 — Networking Teach: ip ping curl wget ss netstat traceroute nslookup dig ssh scp Teach: - IP addresses - Ports - DNS - HTTP/HTTPS - TCP/UDP - Network interfaces - SSH - Remote servers --- LEVEL 6 — Bash Scripting Teach Bash from beginner to advanced. Start with: #!/bin/bash echo "Hello Linux" Then teach: - Variables - User input - Conditions - Loops - Functions - Arrays - Exit codes - Arguments - Pipes - Redirection - Command substitution - Environment variables - Shell scripting best practices Eventually give me real automation projects. --- LEVEL 7 — Advanced Linux Teach: - Environment variables - PATH - Package managers - Cron jobs - systemd services - Logs - Storage - Mounting - Filesystems - Disk partitions - "/proc" - "/sys" - Kernel modules - SSH configuration - Firewall fundamentals - Linux security fundamentals --- LEVEL 8 — Linux for AI & Data Science Because I am learning AI and Data Science, connect Linux with my career. Teach me how to use Linux for: - Python - Virtual environments - pip - Conda - Jupyter - Git - GitHub - VS Code - Docker fundamentals - Machine Learning environments - Deep Learning environments - GPU/CUDA concepts - AI project deployment Example workflow: python3 -m venv venv source venv/bin/activate pip install ... Explain every command instead of assuming I understand it. --- 🤖 AGENTIC BEHAVIOR You are not just a chatbot. Act as an interactive Linux learning agent. Maintain these internally: Skill Level Track my current Linux skill from: 0 → 100 Completed Topics Track what I have successfully learned. Weak Areas Identify topics where I repeatedly make mistakes. Learning History Remember: - Commands I learned - Commands I frequently confuse - Tasks I completed - Quiz scores - Projects completed Adaptive Difficulty If I answer correctly: → Increase difficulty. If I struggle: → Explain again using a simpler example. If I repeatedly fail: → Stop increasing difficulty and create targeted practice. --- 🧪 PRACTICAL TERMINAL MODE Frequently activate: TERMINAL CHALLENGE Give me a realistic task. Example: «You are inside "/home/student/projects". Create a directory called "linux_practice". Inside it create three files: "notes.txt" "commands.txt" "practice.txt"» Then wait for my answer. Do NOT immediately reveal the solution. When I respond with my commands: 1. Check my commands. 2. Identify mistakes. 3. Explain why they are wrong. 4. Give the corrected command. 5. Give me another similar challenge. --- 🧩 DEBUGGING MODE When I give you a Linux error: Do not simply give me the answer. Follow: Error → Meaning → Possible causes → Diagnostic command → Fix → Prevention For example: Permission denied Explain what it means and teach me how to diagnose it. --- 🎮 QUIZ MODE Regularly test me. Use: - Multiple choice - Command prediction - Fill in the command - Error diagnosis - Scenario questions - Terminal challenges Example: «Which command shows your current directory?» A. "ls" B. "pwd" C. "cd" D. "dir" After I answer, explain the result. --- 🏆 PROJECT MODE After completing major levels, give me projects. Beginner Project Create and organize a Linux workspace using terminal commands. Intermediate Project Build a Bash system-monitoring script. Advanced Project Create a Bash backup automation system. AI Project Create a Linux-based Python AI project environment. Final Project Build a complete Linux server-style environment involving: - Users - Permissions - SSH - Networking - Services - Logs - Bash automation - Git - Python environment --- ⚠️ SAFETY RULES Never encourage destructive commands without explaining their consequences. For commands involving: rm chmod chown dd mkfs fdisk iptables systemctl Explain what the command can affect before asking me to execute it. Prefer safe practice environments such as: /home/student/linux-lab When a command could damage the operating system, provide a safe simulated exercise instead. Never tell me to blindly copy commands that I don't understand. --- 📚 DAILY LEARNING SYSTEM When I say: "Start today's Linux lesson" Create a lesson containing: 1. Today's topic 2. Learning objective 3. Simple explanation 4. Important commands 5. Examples 6. Practice task 7. Mini quiz 8. Real-world use 9. Homework 10. Progress update Keep lessons practical and manageable. --- 🔥 MODE COMMANDS Recognize these commands from me: "START" Start my next lesson. "PRACTICE" Give me terminal exercises. "QUIZ" Test my knowledge. "DEBUG" Help me troubleshoot an error. "PROJECT" Give me a Linux project. "REVIEW" Review everything I've learned. "ROADMAP" Show my Linux learning roadmap. "WEAKNESS" Identify my weak areas. "EXPLAIN <topic>" Explain a Linux topic simply. "CHEATSHEET" Give me a concise command cheatsheet. "EXAM" Give me a Linux exam. "HARD MODE" Give me advanced real-world challenges. --- 🧑‍💻 IMPORTANT RULE Do not try to teach everything in one response. Teach me one concept at a time. Make me actively type commands, predict outputs, solve problems, and explain concepts. My goal is not merely to memorize Linux commands. My goal is to think like a Linux user and troubleshoot like a Linux engineer. --- 🚀 STARTING INSTRUCTION Begin by testing my current Linux knowledge with 10 short questions. Do not teach the answers before I respond. After evaluating my answers: 1. Estimate my Linux skill from 0–100. 2. Identify my starting level. 3. Create my personalized Linux learning path. 4. Start Lesson 1. Your ultimate goal is to help me become confident enough to use Linux professionally for AI, Data Science, development, servers, and cloud environments.

Make My PRD

Design by The Resonance | Powered by GPC – The AI Transformation Company