= Seven Tentacles Teacher Guide
:toc: left
:toclevels: 3
:icons: font

*A Guide for Educators Using Seven Tentacles*

== Introduction

Welcome, educator! This guide will help you use Seven Tentacles effectively in your classroom or learning environment.

Seven Tentacles teaches compiler architecture concepts to children ages 8-18 through a "progressive reveal" approach - students play games with colorful mascots, not realizing they're learning graduate-level computer science.

== Quick Start

=== Setting Up

1. Visit the Seven Tentacles platform (or host locally)
2. Create a class/group for your students
3. Assign students to start at the appropriate stage:
   * Ages 8-12: Cuttle stage
   * Ages 13-14: Squidlet stage
   * Ages 15: Duet stage
   * Ages 16+: Octopus stage

=== First Session

1. Introduce the mascots (don't reveal the CS concepts!)
2. Let students choose their favorite agent color
3. Begin with Lesson 1 for that agent
4. Allow free exploration

== The Seven Agents

[cols="1,2,3,3"]
|===
|Agent |Child Name |Teacher Knows |Student Thinks

|🔴 Red |Speedy Red |Parsing, lexical analysis |Racing and speed games
|🟠 Orange |Juggler Orange |Concurrency, async |Juggling and coordination
|🟡 Yellow |Safety Yellow |Type systems |Sorting and organizing
|🟢 Green |Builder Green |AST construction |Building and construction
|🔵 Blue |Detective Blue |Verification |Mystery solving
|🟣 Indigo |Magic Indigo |Metaprogramming |Magic and spells
|🟤 Violet |Teacher Violet |Language governance |Rules and fairness
|===

== Classroom Integration

=== Ages 8-10 (Primary/Elementary)

**Time:** 30-45 minutes per session

**Approach:**

* Focus on one agent at a time
* Use the visual Me Language exclusively
* Emphasize play over instruction
* Let students "discover" patterns

**Curriculum Links:**

* Mathematics: Patterns, sequences, sorting
* Literacy: Following instructions, logic
* Art: Creating visual programs

=== Ages 11-12 (Upper Elementary)

**Time:** 45-60 minutes per session

**Approach:**

* Introduce agent collaboration concepts
* Begin transitioning to more complex challenges
* Encourage peer collaboration
* Start discussing "what you're really learning"

**Curriculum Links:**

* Mathematics: Algorithms, efficiency
* Science: Systems thinking
* Computing: Introduction to programming logic

=== Ages 13-14 (Middle School)

**Time:** 60 minutes per session

**Approach:**

* Transition to Solo Language
* Reveal agent names change ("Speedy Red" → "Fast Finder Red")
* Explicitly connect games to CS concepts
* Begin text-based coding

**Curriculum Links:**

* Computing: Types, algorithms, data structures
* Mathematics: Logic, proof
* Design: System design

=== Ages 15+ (High School)

**Time:** 60-90 minutes per session

**Approach:**

* Use Duet and Ensemble languages
* Full technical vocabulary
* Connect to real compiler concepts
* Independent projects

**Curriculum Links:**

* Computer Science: Compiler design, formal methods
* Mathematics: Formal logic, type theory
* Engineering: System architecture

== Lesson Structure

=== Recommended Flow

1. **Welcome (5 min):** Agent introduces the lesson
2. **Explore (15-20 min):** Interactive game/activity
3. **Practice (15-20 min):** Guided challenges
4. **Reflect (5-10 min):** What did we learn?
5. **Extend (optional):** Take-home challenges

=== The "Secret Learning" Moment

At the end of each lesson, there's a "What You Really Learned" section.

**For younger students (8-12):**
Don't emphasize this! Let them see it, but don't explain.

**For older students (13+):**
Discuss this explicitly. Help them make connections.

== Differentiation

=== For Advanced Learners

* Skip to harder challenges
* Combine multiple agents earlier
* Introduce text-based languages sooner
* Provide extension projects

=== For Struggling Learners

* More time on each concept
* Extra visual scaffolding
* Peer support/pairing
* Focus on preferred agent

=== For Different Learning Styles

* **Visual:** Use the Me Language blocks
* **Kinesthetic:** Emphasize drag-and-drop games
* **Auditory:** Use agent voice features
* **Reading/Writing:** Transition to text languages

== Assessment Ideas

=== Informal Assessment

* Observe game completion rates
* Note which agents students prefer
* Listen to peer discussions
* Watch problem-solving approaches

=== Formal Assessment

* Challenge completions per lesson
* Stage transition readiness checks
* Portfolio of created programs
* Final compiler project (Octopus stage)

=== Student Self-Assessment

* Progress dashboards
* Agent "interviews"
* Reflection journals
* Peer code reviews

== Troubleshooting

=== "This is too easy!"

* Move to harder challenges
* Combine agents earlier
* Introduce competitions
* Provide extension projects

=== "I'm stuck!"

* Revisit previous lessons
* Try a different agent
* Pair with another student
* Use hints system

=== "I don't like [agent]!"

* Let them choose another
* Try the same concept via different agent
* Return later when ready

=== "When do we learn REAL programming?"

* Explain: "You already are!"
* Show connection to real languages
* Provide comparison examples

== Parent Communication

=== What to Tell Parents

"Your child is learning computer science fundamentals through game-based learning. They're developing skills in logic, problem-solving, and computational thinking that will prepare them for programming and beyond."

=== What NOT to Tell Parents (Yet)

Don't reveal that they're learning compiler architecture! Part of the magic is the eventual "aha!" moment when students realize what they've been learning.

== Resources

=== Online

* Platform: [URL]
* Teacher forum: [URL]
* Curriculum materials: [URL]

=== Offline

* Printable lesson guides
* Unplugged activities
* Assessment rubrics

== Frequently Asked Questions

**Q: What if a student is older but new to programming?**

Start them at Cuttle stage regardless of age. The content will move faster for older students.

**Q: Can students skip ahead?**

Yes, if they demonstrate mastery. Each stage has assessment challenges.

**Q: Do I need programming experience to teach this?**

No! The system is designed for non-specialist teachers. The pedagogy guide explains everything.

**Q: How does this connect to computing curricula?**

See the curriculum links in each age section above. Seven Tentacles covers algorithmic thinking, data representation, and programming concepts.

---

_Thank you for being part of the Seven Tentacles journey! Together, we're creating a generation of young people who truly understand how computers work._
