New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Reading Teacher

by jamesrochabrun in jamesrochabrun/skills

Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10.

MITAuto-check passedEducation

Install Reading Teacher

skills CLI
$ npx skills add jamesrochabrun/skills --skill reading-teacher -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install jamesrochabrun/skills reading-teacher --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/jamesrochabrun/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/reading-teacher .claude/skills/reading-teacher && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
reading-teacher
GitHub stars
216
Token cost
~5.9k tokens
SKILL.md length
1,040 words
Files
6 (incl. scripts, references)
Skills in repo
23
Repo updated
First seen
Licence
MIT

At a glance

Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10.

  • Works in 5 steps: Developmentally Appropriate → Multi-Sensory Engagement → Play-Based Learning → …
  • Education work in your project
  • SKILL.md covers What This Skill Does, Why This Skill Matters, Core Principles and Reading Stages Covered, plus 4 more sections
  • Runs Shell scripts from its folder

What it does

Reading Teacher is an agent skill from jamesrochabrun/skills. Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10. Creates visual playgrounds, phonics games, and interactive stories to build reading skills from letter recognition to comprehension.

Its SKILL.md is about 5.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 7 other files, including scripts and reference files (for example `references/comprehension.md`, `references/phonics.md` and `references/sight_words.md`).

It sits in Education. The licence is MIT.

When your agent uses it

  • Education work in your project

Example prompts

  • “/reading-teacher”

Requirements

  • A Bash shell

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Developmentally Appropriate
  2. Multi-Sensory Engagement
  3. Play-Based Learning
  4. Systematic Instruction
  5. Positive Reinforcement

What it can do on your machine

Read from SKILL.md and the folder at commit 2482c17. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 2 files in scripts/ (Shell), which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Reading Teacher loads about 5.9k tokens when it runs, and up to ~16k if it reads all its reference files. Until then it costs about 66 tokens; SKILL.md has 1,040 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~66
When it runs · the whole SKILL.md, loaded when a task matches
~5.9k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~16k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from jamesrochabrun/skills at commit 2482c17, republished under its MIT licence (© jamesrochabrun). 1,040 words, ~5,856 tokens.

Download SKILL.mdSave it as .claude/skills/reading-teacher/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
reading-teacher
description
Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10. Creates visual playgrounds, phonics games, and interactive stories to build reading skills from letter recognition to comprehension.

Reading Teacher

An interactive, playful reading teacher that instantly generates engaging learning experiences through interactive artifacts, visual playgrounds, and gamified challenges for young learners.

What This Skill Does

Transforms reading education into interactive, visual experiences:

  • Instant Playground Generation - Creates interactive HTML/JS artifacts on demand
  • Age-Appropriate Content - Tailored for ages 1-10 with developmental stages
  • Multi-Sensory Learning - Visual, auditory, and interactive elements
  • Phonics & Sight Words - Systematic phonics instruction and high-frequency words
  • Story Building - Interactive story creation and comprehension
  • Gamification - Stars, badges, rewards, and progress tracking
  • Parent/Teacher Tools - Progress reports and customization options

Why This Skill Matters

Traditional reading instruction:

  • Limited engagement and interactivity
  • One-size-fits-all approach
  • Difficult to maintain young attention spans
  • Limited practice opportunities
  • Hard to track individual progress

With this skill:

  • Instant engagement through games
  • Personalized to child's level
  • Fun, rewarding experiences
  • Unlimited practice variations
  • Clear progress tracking
  • Multi-sensory approach

Core Principles

1. Developmentally Appropriate
  • Age-specific content and challenges
  • Scaffolded learning progression
  • Appropriate complexity levels
  • Sensitive to attention spans
  • Celebrates every milestone
2. Multi-Sensory Engagement
  • Visual letter displays
  • Audio pronunciation
  • Interactive touch/click
  • Animated feedback
  • Colorful, engaging design
3. Play-Based Learning
  • Games over drills
  • Story-driven activities
  • Character companions
  • Reward systems
  • Celebration animations
4. Systematic Instruction
  • Sequential skill building
  • Phonics-based approach
  • High-frequency sight words
  • Comprehension strategies
  • Fluency development
5. Positive Reinforcement
  • Immediate encouragement
  • Visual progress markers
  • Achievement celebrations
  • No negative feedback
  • Growth mindset focus

Reading Stages Covered

Pre-Reading (Ages 1-3)

Skills:

  • Letter recognition (uppercase & lowercase)
  • Letter sounds (phonemic awareness)
  • Environmental print awareness
  • Book handling skills
  • Listening comprehension

Activities:

  • 🔤 Alphabet song with animations
  • 🎨 Letter tracing games
  • 🔊 Sound matching activities
  • 📚 Interactive picture books
  • 🎵 Rhyming word games
Early Reading (Ages 3-5)

Skills:

  • Letter-sound correspondence
  • Beginning phonics (CVC words)
  • Print awareness
  • Simple sight words
  • Picture-text connection

Activities:

  • 🐱 CVC word building (cat, dog, sun)
  • 🎯 Sight word matching games
  • 📖 Simple sentence reading
  • 🧩 Word family exploration
  • ✨ Rhyme time challenges
Beginning Readers (Ages 5-7)

Skills:

  • Phonics patterns (blends, digraphs)
  • Expanding sight word vocabulary
  • Simple sentence reading
  • Basic comprehension
  • Fluency building

Activities:

  • 🌟 Digraph detective games (ch, sh, th)
  • 📝 Sentence building workshops
  • 📚 Decodable story readers
  • 🎭 Character comprehension
  • ⏱️ Fluency practice tracks
Developing Readers (Ages 7-10)

Skills:

  • Advanced phonics patterns
  • Multi-syllable words
  • Reading comprehension strategies
  • Vocabulary development
  • Fluent reading

Activities:

  • 📖 Story comprehension challenges
  • 🔍 Context clue detectives
  • 📚 Chapter book companions
  • ✍️ Story writing studios
  • 🎯 Vocabulary builders

Interactive Playground Examples

Example 1: Letter Land Adventure (Ages 1-3)

User asks: "Help my toddler learn letters"

Teacher generates:

html
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>🌈 Letter Land Adventure!</title>
  <style>
    * { margin: 0; padding: 0; box-sizing: border-box; }
    body {
      font-family: 'Comic Sans MS', 'Chalkboard SE', cursive, sans-serif;
      background: linear-gradient(135deg, #a8edea 0%, #fed6e3 100%);
      min-height: 100vh;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 20px;
      color: #333;
    }
    .header {
      text-align: center;
      margin-bottom: 30px;
    }
    h1 {
      font-size: 3em;
      color: #FF6B9D;
      text-shadow: 3px 3px 6px rgba(0,0,0,0.1);
      margin-bottom: 10px;
    }
    .stars {
      font-size: 2em;
      background: rgba(255,255,255,0.8);
      padding: 10px 30px;
      border-radius: 30px;
      display: inline-block;
    }
    .letter-display {
      background: white;
      width: 400px;
      height: 400px;
      border-radius: 50%;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 15em;
      font-weight: bold;
      color: #FF6B9D;
      box-shadow: 0 20px 60px rgba(0,0,0,0.2);
      margin: 20px;
      cursor: pointer;
      transition: all 0.3s ease;
      user-select: none;
    }
    .letter-display:hover {
      transform: scale(1.05);
      box-shadow: 0 30px 80px rgba(0,0,0,0.3);
    }
    .letter-display:active {
      transform: scale(0.95);
    }
    .controls {
      display: flex;
      gap: 20px;
      margin: 20px;
      flex-wrap: wrap;
      justify-content: center;
    }
    .btn {
      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
      color: white;
      border: none;
      padding: 20px 40px;
      font-size: 1.5em;
      border-radius: 20px;
      cursor: pointer;
      transition: transform 0.2s;
      font-weight: bold;
      box-shadow: 0 10px 25px rgba(0,0,0,0.2);
    }
    .btn:hover { transform: translateY(-5px); }
    .btn:active { transform: translateY(0); }
    .letter-name {
      font-size: 2em;
      margin: 20px;
      color: #667eea;
      font-weight: bold;
    }
    .celebration {
      position: fixed;
      top: 50%;
      left: 50%;
      transform: translate(-50%, -50%) scale(0);
      font-size: 10em;
      animation: celebrate 1s ease forwards;
      pointer-events: none;
      z-index: 1000;
    }
    @keyframes celebrate {
      0% { transform: translate(-50%, -50%) scale(0) rotate(0deg); }
      50% { transform: translate(-50%, -50%) scale(1.5) rotate(180deg); }
      100% { transform: translate(-50%, -50%) scale(1) rotate(360deg); opacity: 0; }
    }
    .alphabet-grid {
      display: grid;
      grid-template-columns: repeat(auto-fit, minmax(80px, 1fr));
      gap: 10px;
      max-width: 800px;
      margin: 20px;
    }
    .alphabet-letter {
      background: white;
      padding: 20px;
      border-radius: 15px;
      font-size: 2em;
      text-align: center;
      cursor: pointer;
      transition: all 0.2s;
      box-shadow: 0 5px 15px rgba(0,0,0,0.1);
      font-weight: bold;
      color: #667eea;
    }
    .alphabet-letter:hover {
      transform: scale(1.1);
      background: #FFD700;
    }
    .alphabet-letter.learned {
      background: #4CAF50;
      color: white;
    }
    @media (max-width: 768px) {
      .letter-display { width: 300px; height: 300px; font-size: 10em; }
      h1 { font-size: 2em; }
    }
  </style>
</head>
<body>
  <div class="header">
    <h1>🌈 Letter Land Adventure!</h1>
    <div class="stars">
      Stars: <span id="stars">0</span> ⭐
    </div>
  </div>

  <div class="letter-display" id="letterDisplay" onclick="speakLetter()">
    A
  </div>

  <div class="letter-name" id="letterName">
    Click the letter to hear its name and sound!
  </div>

  <div class="controls">
    <button class="btn" onclick="nextLetter()">Next Letter ➡️</button>
    <button class="btn" onclick="randomLetter()">Random Letter 🎲</button>
    <button class="btn" onclick="showAlphabet()">Show All 🔤</button>
  </div>

  <div class="alphabet-grid" id="alphabetGrid" style="display: none;"></div>

  <script>
    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
    const letterNames = {
      'A': 'Apple', 'B': 'Ball', 'C': 'Cat', 'D': 'Dog', 'E': 'Elephant',
      'F': 'Fish', 'G': 'Goat', 'H': 'Hat', 'I': 'Ice Cream', 'J': 'Juice',
      'K': 'Kite', 'L': 'Lion', 'M': 'Moon', 'N': 'Nest', 'O': 'Orange',
      'P': 'Pig', 'Q': 'Queen', 'R': 'Rabbit', 'S': 'Sun', 'T': 'Tiger',
      'U': 'Umbrella', 'V': 'Violin', 'W': 'Whale', 'X': 'X-ray', 'Y': 'Yellow', 'Z': 'Zebra'
    };
    const letterSounds = {
      'A': 'ah', 'B': 'buh', 'C': 'kuh', 'D': 'duh', 'E': 'eh',
      'F': 'fuh', 'G': 'guh', 'H': 'huh', 'I': 'ih', 'J': 'juh',
      'K': 'kuh', 'L': 'luh', 'M': 'muh', 'N': 'nuh', 'O': 'ah',
      'P': 'puh', 'Q': 'kwuh', 'R': 'ruh', 'S': 'sss', 'T': 'tuh',
      'U': 'uh', 'V': 'vuh', 'W': 'wuh', 'X': 'ks', 'Y': 'yuh', 'Z': 'zzz'
    };

    let currentIndex = 0;
    let stars = 0;
    let learnedLetters = new Set();
    const colors = ['#FF6B9D', '#4ECDC4', '#FFE66D', '#A8E6CF', '#FF8B94', '#C7CEEA'];

    function updateDisplay(letter) {
      const display = document.getElementById('letterDisplay');
      display.textContent = letter;
      display.style.color = colors[Math.floor(Math.random() * colors.length)];

      const name = document.getElementById('letterName');
      name.textContent = `${letter} is for ${letterNames[letter]}!`;
    }

    function speakLetter() {
      const letter = document.getElementById('letterDisplay').textContent;

      // Award star
      stars++;
      document.getElementById('stars').textContent = stars;

      // Mark as learned
      if (!learnedLetters.has(letter)) {
        learnedLetters.add(letter);
        updateAlphabetGrid();
      }

      // Show celebration
      celebrate('🎉');

      // Simulate speech (in real implementation, use Web Speech API)
      const name = document.getElementById('letterName');
      name.textContent = `${letter}! ${letter} says "${letterSounds[letter]}"`;

      // Change color
      const display = document.getElementById('letterDisplay');
      display.style.color = colors[Math.floor(Math.random() * colors.length)];

      // Could use Web Speech API here:
      // const utterance = new SpeechSynthesisUtterance(`${letter}. ${letter} is for ${letterNames[letter]}`);
      // speechSynthesis.speak(utterance);
    }

    function nextLetter() {
      currentIndex = (currentIndex + 1) % alphabet.length;
      updateDisplay(alphabet[currentIndex]);
    }

    function randomLetter() {
      currentIndex = Math.floor(Math.random() * alphabet.length);
      updateDisplay(alphabet[currentIndex]);
      celebrate('✨');
    }

    function showAlphabet() {
      const grid = document.getElementById('alphabetGrid');
      if (grid.style.display === 'none') {
        grid.style.display = 'grid';
        if (grid.children.length === 0) {
          alphabet.forEach(letter => {
            const div = document.createElement('div');
            div.className = 'alphabet-letter';
            div.textContent = letter;
            div.onclick = () => {
              currentIndex = alphabet.indexOf(letter);
              updateDisplay(letter);
              speakLetter();
            };
            grid.appendChild(div);
          });
        }
      } else {
        grid.style.display = 'none';
      }
    }

    function updateAlphabetGrid() {
      const grid = document.getElementById('alphabetGrid');
      if (grid.children.length > 0) {
        Array.from(grid.children).forEach((div, i) => {
          if (learnedLetters.has(alphabet[i])) {
            div.classList.add('learned');
          }
        });
      }
    }

    function celebrate(emoji) {
      const celebration = document.createElement('div');
      celebration.className = 'celebration';
      celebration.textContent = emoji;
      document.body.appendChild(celebration);
      setTimeout(() => celebration.remove(), 1000);
    }

    // Initialize
    updateDisplay(alphabet[0]);

    // Encourage interaction
    setTimeout(() => {
      const name = document.getElementById('letterName');
      name.textContent = '👆 Click the letter to hear it!';
    }, 3000);
  </script>
</body>
</html>

Features:

  • Large, colorful letter display
  • Click to hear letter name and sound
  • Progress tracking with stars
  • Alphabet grid showing learned letters
  • Randomization for variety
  • Encouraging animations
  • Mobile-friendly touch interface
Example 2: Sight Word Safari (Ages 5-7)

User asks: "Practice sight words for first grade"

Teacher generates: Interactive safari game with:

  • High-frequency Dolch/Fry words
  • Word recognition challenges
  • Sentence building activities
  • Timed reading practice
  • Progress badges and rewards
Example 3: Story Builder Studio (Ages 7-10)

User asks: "Help with reading comprehension"

Teacher generates: Interactive story workshop with:

  • Choose-your-own-adventure format
  • Comprehension questions embedded
  • Vocabulary highlighting
  • Character analysis tools
  • Story sequencing activities

Gamification System

Rewards & Stars
  • Letter Stars (1 star): Learn a new letter
  • Word Stars (5 stars): Read a new word
  • Story Stars (10 stars): Complete a story
  • Speed Stars (3 stars): Quick recognition
  • Perfect Stars (20 stars): 100% accuracy
Achievement Badges
  • 🌟 ABC Master: Learn all 26 letters
  • 📖 First Reader: Read first complete sentence
  • 🏆 Word Wizard: Master 50 sight words
  • 🎯 Perfect Week: Practice 7 days in a row
  • 🚀 Speed Reader: Read 20 words in 1 minute
  • 📚 Story Time: Complete 10 stories
  • 🎨 Creative Writer: Build own story
  • ⭐ Super Star: Earn 1000 total stars
Progress Tracking
  • Letters learned (26 total)
  • Sight words mastered
  • Stories completed
  • Reading streak (days)
  • Time spent reading
  • Accuracy percentage
  • Reading level advancement
Celebration Animations
  • Confetti for achievements
  • Star explosions for correct answers
  • Character animations
  • Sound effects (optional)
  • Progress bar fills
  • Level-up animations

Learning Activities by Type

Show full SKILL.md (417 more words)Show less
Letter Recognition

Activities:

  • Alphabet song with animations
  • Letter matching games
  • Upper/lowercase pairing
  • Letter tracing (touch/mouse)
  • Find the letter challenges
  • Letter sorting activities

Example Code:

javascript
function createLetterMatch() {
  const uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
  const lowercase = 'abcdefghijklmnopqrstuvwxyz'.split('');

  // Shuffle and match pairs
  const pairs = uppercase.map((u, i) => ({
    upper: u,
    lower: lowercase[i],
    matched: false
  }));

  return pairs;
}
Phonics Practice

Activities:

  • Sound matching (letter to sound)
  • CVC word building (cat, dog, run)
  • Word families (-at, -an, -ig)
  • Rhyming word games
  • Blend practice (bl, cr, st)
  • Digraph detection (ch, sh, th)

Example:

javascript
const wordFamilies = {
  'at': ['cat', 'bat', 'rat', 'hat', 'mat', 'sat'],
  'an': ['can', 'man', 'pan', 'ran', 'van', 'fan'],
  'ig': ['big', 'dig', 'fig', 'pig', 'wig', 'jig']
};

function generateWordFamily(family) {
  return wordFamilies[family].map(word => ({
    word: word,
    letters: word.split(''),
    sound: `/${family}/`
  }));
}
Sight Word Training

High-Frequency Words (Dolch/Fry Lists):

Pre-K:

javascript
const preK = ['a', 'and', 'away', 'big', 'blue', 'can', 'come',
              'down', 'find', 'for', 'funny', 'go', 'help', 'here',
              'I', 'in', 'is', 'it', 'jump', 'little', 'look', 'make',
              'me', 'my', 'not', 'one', 'play', 'red', 'run', 'said',
              'see', 'the', 'three', 'to', 'two', 'up', 'we', 'where',
              'yellow', 'you'];

First Grade:

javascript
const firstGrade = ['after', 'again', 'an', 'any', 'as', 'ask', 'by',
                    'could', 'every', 'fly', 'from', 'give', 'going',
                    'had', 'has', 'her', 'him', 'his', 'how', 'just',
                    'know', 'let', 'live', 'may', 'of', 'old', 'once',
                    'open', 'over', 'put', 'round', 'some', 'stop',
                    'take', 'thank', 'them', 'then', 'think', 'walk',
                    'were', 'when'];

Interactive Sight Word Game:

javascript
function createSightWordChallenge(wordList, timeLimit = 60) {
  let score = 0;
  let currentWord = '';
  let timeRemaining = timeLimit;

  function nextWord() {
    currentWord = wordList[Math.floor(Math.random() * wordList.length)];
    displayWord(currentWord);
  }

  function checkAnswer(userInput) {
    if (userInput.toLowerCase() === currentWord.toLowerCase()) {
      score++;
      celebrate();
      nextWord();
    }
  }

  return { nextWord, checkAnswer, score };
}
Reading Comprehension

Strategies:

  • Predicting what happens next
  • Identifying main characters
  • Recalling story details
  • Understanding cause/effect
  • Making inferences
  • Visualizing scenes

Interactive Questions:

javascript
const comprehensionQuestions = {
  'The Cat and the Hat': [
    {
      question: 'Who are the main characters?',
      type: 'multiple-choice',
      options: ['Cat, Kids', 'Dog, Bird', 'Fish, Mom'],
      answer: 'Cat, Kids'
    },
    {
      question: 'Where does the story take place?',
      type: 'multiple-choice',
      options: ['Outside', 'At home', 'At school'],
      answer: 'At home'
    },
    {
      question: 'What did you like about the story?',
      type: 'open-ended',
      encouragement: 'Great thinking!'
    }
  ]
};
Story Building

Components:

  • Character selection
  • Setting choices
  • Problem/solution structure
  • Sequence of events
  • Ending options
  • Illustration tools
javascript
const storyElements = {
  characters: ['🐱 Cat', '🐶 Dog', '🦊 Fox', '🐻 Bear', '🦁 Lion'],
  settings: ['🏠 House', '🌳 Forest', '🏖️ Beach', '🏰 Castle', '🚀 Space'],
  problems: ['Lost something', 'Made a friend', 'Went on adventure', 'Solved mystery'],
  solutions: ['Found it!', 'Worked together', 'Used creativity', 'Never gave up']
};

function buildStory(selections) {
  return `Once upon a time, there was a ${selections.character}.
          The ${selections.character} lived in a ${selections.setting}.
          One day, the ${selections.character} ${selections.problem}.
          In the end, ${selections.solution}!`;
}

Parent/Teacher Tools

Progress Reports
javascript
const progressReport = {
  childName: 'Emma',
  age: 6,
  level: 'Beginning Reader',
  stats: {
    lettersLearned: 26,
    sightWordsMastered: 45,
    storiesCompleted: 12,
    currentStreak: 7,
    totalTimeMinutes: 240
  },
  strengths: ['Letter recognition', 'Phonics', 'Enthusiasm'],
  workingOn: ['Sight words', 'Reading fluency'],
  nextSteps: ['Practice high-frequency words', 'Read aloud daily']
};
Customization Options
  • Adjust difficulty level
  • Select word lists
  • Choose themes/characters
  • Set time limits
  • Enable/disable sound
  • Track multiple children
  • Export progress data

Technical Implementation

Text-to-Speech (Web Speech API)
javascript
function speakText(text, rate = 1.0) {
  if ('speechSynthesis' in window) {
    const utterance = new SpeechSynthesisUtterance(text);
    utterance.rate = rate;
    utterance.pitch = 1.2; // Higher pitch for kids
    utterance.volume = 1.0;
    speechSynthesis.speak(utterance);
  } else {
    // Fallback: show text with pronunciation guide
    showPronunciation(text);
  }
}
Interactive Word Building
javascript
function createWordBuilder(targetWord) {
  const letters = targetWord.split('');
  const scrambled = shuffle([...letters]);

  let builtWord = [];

  function addLetter(letter) {
    builtWord.push(letter);
    updateDisplay();

    if (builtWord.join('') === targetWord) {
      celebrate('Correct!');
      return true;
    }
    return false;
  }

  function removeLetter() {
    builtWord.pop();
    updateDisplay();
  }

  return { addLetter, removeLetter, scrambled };
}
Reading Fluency Timer
javascript
class FluencyTracker {
  constructor(text) {
    this.text = text;
    this.wordCount = text.split(' ').length;
    this.startTime = null;
    this.endTime = null;
  }

  start() {
    this.startTime = Date.now();
  }

  stop() {
    this.endTime = Date.now();
    return this.calculate();
  }

  calculate() {
    const seconds = (this.endTime - this.startTime) / 1000;
    const minutes = seconds / 60;
    const wpm = Math.round(this.wordCount / minutes);

    return {
      wordsPerMinute: wpm,
      timeSeconds: seconds,
      wordCount: this.wordCount,
      rating: this.getRating(wpm)
    };
  }

  getRating(wpm) {
    // Age-appropriate WPM benchmarks
    if (wpm >= 100) return '🏆 Excellent!';
    if (wpm >= 70) return '⭐ Great job!';
    if (wpm >= 50) return '👍 Good work!';
    return '💪 Keep practicing!';
  }
}

Reference Materials

All included in /references:

  • phonics.md - Phonics patterns, rules, and activities
  • sight_words.md - Dolch and Fry word lists by level
  • comprehension.md - Reading strategies and question types
  • stories.md - Decodable texts and story templates

Scripts

All in /scripts:

  • generate_playground.sh - Create interactive reading playground
  • generate_game.sh - Build phonics or sight word game
  • generate_story.sh - Create interactive story

Best Practices

DO:

✅ Use large, clear fonts (minimum 24pt for beginners) ✅ Include audio pronunciation ✅ Provide immediate positive feedback ✅ Use colorful, engaging visuals ✅ Celebrate every success ✅ Keep sessions short (5-15 minutes) ✅ Make it playful and fun ✅ Track progress visibly

DON'T:

❌ Use complex vocabulary ❌ Show negative feedback ❌ Make activities too long ❌ Use small or hard-to-read text ❌ Skip audio support ❌ Make it feel like work ❌ Overwhelm with too many choices ❌ Forget to celebrate progress

Example Interactions

Toddler (Age 2):

"Teach my toddler the alphabet"

Generates: Interactive Letter Land with clickable letters, sounds, animations, and tracking

Kindergarten (Age 5):

"Help with CVC words"

Generates: Word family game with cat, bat, rat - drag-and-drop letter building with sounds

First Grade (Age 6):

"Practice sight words"

Generates: Sight Word Safari with timed challenges, sentences, and progress badges

Second Grade (Age 7):

"Reading comprehension practice"

Generates: Interactive story with embedded questions, vocabulary help, and rewards

Summary

This skill transforms reading education by:

  • Instant Engagement - Generates playgrounds immediately
  • Multi-Sensory - Visual, audio, interactive elements
  • Developmentally Appropriate - Age 1-10 coverage
  • Systematic - Phonics-based progression
  • Gamified - Stars, badges, celebrations
  • Effective - Research-based methods
  • Fun - Play-based learning

"Every child can learn to read with the right support and encouragement." 📚

Usage: Ask for help with any reading skill - letter recognition, phonics, sight words, comprehension - and get an instant, interactive learning experience tailored to your child's level!

© jamesrochabrun, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts, references) in skills/reading-teacher of jamesrochabrun/skills.

  • SKILL.md
  • references/comprehension.md
  • references/phonics.md
  • references/sight_words.md
  • scripts/generate_game.sh
  • scripts/generate_playground.sh

Open the folder on GitHubat commit 2482c17

Compare with similar skills

Reading Teacher next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Reading Teacher compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Reading Teacher this skilljamesrochabrun/skills216—~5.9kAutomated safety check: PassMIT
DeepTutor CLIHKUDS/DeepTutor41k—~2.8kAutomated safety check: PassApache-2.0
AI Engineering Placement Quizrohitg00/ai-engineering-from-scratch66k—~2kAutomated safety check: PassMIT
Deep Reading Analystginobefun/deep-reading-analyst-skill3534 repos~3.6kAutomated safety check: PassMIT
OpenMAIC Setup and ExtensionTHU-MAIC/OpenMAIC40k—~1.7kAutomated safety check: NotesMIT
Codebase to Coursezarazhangrui/codebase-to-course5.7k—~4.4kAutomated safety check: PassNone

Similar skills

  • DeepTutor CLI

    HKUDS/DeepTutor

    Teaches the agent to set up and run DeepTutor from the command line: chat and capabilities, knowledge bases, partners, memory, sessions, notebooks and the server or Web app.

    41k GitHub stars~2.8k tokensUpdated yesterday
    EducationAuto-check passed

  • AI Engineering Placement Quiz

    rohitg00/ai-engineering-from-scratch

    Runs a 10-question quiz across five areas to place a learner in the AI Engineering from Scratch curriculum, so they skip what they already know.

    66k GitHub stars~2k tokensUpdated today
    EducationAuto-check passed

  • Deep Reading Analyst

    ginobefun/deep-reading-analyst-skill

    Comprehensive framework for deep analysis of articles, papers, and long-form content using 10+ thinking models (SCQA, 5W2H, critical thinking, inversion, mental models, first principles, systems…

    353 GitHub starsUsed in 4 repos~3.6k tokens
    EducationAuto-check passed

  • OpenMAIC Setup and Extension

    THU-MAIC/OpenMAIC

    Guides setup, classroom generation and secondary development for OpenMAIC, the multi-agent interactive classroom, one confirmed phase at a time.

    40k GitHub stars~1.7k tokensUpdated today
    EducationAuto-check: notes

  • Codebase to Course

    zarazhangrui/codebase-to-course

    Turns a codebase into an interactive single-page HTML course for non-technical learners, with scroll modules, animated diagrams, quizzes and plain-English code translations.

    5.7k GitHub stars~4.4k tokensUpdated 6 mo ago
    EducationAuto-check passed

  • Zhang Xuefeng Perspective

    alchaincyf/zhangxuefeng-skill

    Answers education and career questions in the voice of Zhang Xuefeng, looking up current employment and admissions data before giving a direct verdict.

    10k GitHub stars~2.6k tokensUpdated 1 mo ago
    EducationAuto-check passed

More from jamesrochabrun/skills

All 23 skills in this repo

  • Prd Generator

    jamesrochabrun/skills

    Generate comprehensive Product Requirements Documents (PRDs) for product managers.

    216 GitHub starsUsed in 2 repos~3.8k tokens
    Auto-check passed

  • Technical Launch Planner

    jamesrochabrun/skills

    Plan and execute technical product launches for developer tools, APIs, and technical products.

    216 GitHub starsUsed in 1 repo~3.8k tokens
    Auto-check passed

  • Design Brief Generator

    jamesrochabrun/skills

    Generate comprehensive design briefs for design projects. An agent skill from jamesrochabrun/skills.

    216 GitHub stars~3.3k tokensUpdated 8 mo ago
    Auto-check passed

  • Git Worktrees

    jamesrochabrun/skills

    Manage Git worktrees for parallel Claude Code development. An agent skill from jamesrochabrun/skills.

    216 GitHub stars~4.2k tokensUpdated 8 mo ago
    Auto-check passed

  • Content Brief Generator

    jamesrochabrun/skills

    Generate comprehensive content briefs for writers, ensuring clarity, alignment, and strategic content creation across all formats.

    216 GitHub starsUsed in 1 repo~2.9k tokens
    Auto-check passed

  • LLM Router

    jamesrochabrun/skills

    This skill should be used when users want to route LLM requests to different AI providers (OpenAI, Grok/xAI, Groq, DeepSeek, OpenRouter) using SwiftOpenAI-CLI.

    216 GitHub stars~3.3k tokensUpdated 8 mo ago
    Auto-check passed

Categories

Questions about Reading Teacher

What does Reading Teacher do?

Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10. Reading Teacher is an agent skill from jamesrochabrun/skills. Interactive reading teacher that instantly generates playful, engaging learning experiences for children ages 1-10.

When should I use Reading Teacher?

Reading Teacher fits situations like: education work in your project.

How do I install Reading Teacher in Claude Code?

Run `npx skills add jamesrochabrun/skills --skill reading-teacher -a claude-code`. Or copy the skill folder (skills/reading-teacher in jamesrochabrun/skills) into .claude/skills/reading-teacher in your project. Claude Code loads it when a task matches its description.

How do I install Reading Teacher in Codex?

Run `npx skills add jamesrochabrun/skills --skill reading-teacher -a codex`. Or copy the skill folder (skills/reading-teacher in jamesrochabrun/skills) into .agents/skills/reading-teacher in your project. Codex loads it when a task matches its description.

Can I use Reading Teacher in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jamesrochabrun/skills --skill reading-teacher -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/reading-teacher, .gemini/skills/reading-teacher, .github/skills/reading-teacher and .opencode/skills/reading-teacher in your project.

What does Reading Teacher need to run?

Going by SKILL.md and its folder, Reading Teacher needs a shell for the scripts in its folder. Our summary lists: A Bash shell.

Does Reading Teacher access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Reading Teacher safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Reading Teacher use?

Reading Teacher is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Reading Teacher use?

About 5.9k tokens (SKILL.md is roughly 23k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 11k tokens, read only when the agent opens those files.

What are the alternatives to Reading Teacher?

Skills that share tags, products or a category with Reading Teacher: DeepTutor CLI (HKUDS/DeepTutor, 41k stars), AI Engineering Placement Quiz (rohitg00/ai-engineering-from-scratch, 66k stars), Deep Reading Analyst (ginobefun/deep-reading-analyst-skill, 353 stars) and OpenMAIC Setup and Extension (THU-MAIC/OpenMAIC, 40k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Reading Teacher?

jamesrochabrun (a GitHub user) maintains it in jamesrochabrun/skills, which has 216 GitHub stars. The repository holds 23 skills in this directory. The repository was last updated on January 14, 2026.

Source: jamesrochabrun/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.