AI Collaborate Teaching

CRITICAL: All co-learning content MUST demonstrate this framework (per Section IIa Stage 2 forcing functions):

AI's Three Roles:

1. Teacher: Suggests patterns, architectures, best practices students may not know
2. Student: Learns from student's domain expertise, feedback, corrections
3. Co-Worker: Collaborates as peer, not subordinate

Human's Three Roles:

1. Teacher: Guides AI through clear specifications, provides domain knowledge
2. Student: Learns from AI's suggestions, explores new patterns
3. Orchestrator: Designs collaboration strategy, makes final decisions

The Convergence Loop

Required Pattern for All AI-Integrated Lessons:

┌─────────────────────────────────────────────────────────┐
│  1. Human specifies intent (with context/constraints)   │
│  2. AI suggests approach (may include new patterns)     │
│  3. Human evaluates AND LEARNS ("I hadn't thought of X")│
│  4. AI learns from feedback (adapts to preferences)     │
│  5. CONVERGE on optimal solution (better than either    │
│     could produce alone)                                 │
└─────────────────────────────────────────────────────────┘

Content Requirements:

• ✅ At least ONE instance per lesson where student learns FROM AI's suggestion
• ✅ At least ONE instance where AI adapts TO student's feedback
• ✅ Convergence through iteration (not "perfect on first try")
• ✅ Both parties contributing unique value
• ❌ NEVER present AI as passive tool awaiting commands
• ❌ NEVER show only human teaching AI (one-way instruction)
• ❌ NEVER hide what student learns from AI's approaches

Relationship to Graduated Teaching Pattern (Constitution Principle 13)

This skill complements the graduated teaching pattern:

Graduated Teaching Pattern (Constitution Principle 13) defines WHAT book teaches vs WHAT AI handles:

• Tier 1: Book teaches foundational concepts (stable, won't change)
• Tier 2: AI companion handles complex execution (student specifies, AI executes)
• Tier 3: AI orchestration at scale (10+ items, multi-step workflows)

This skill (AI Collaborate Learning) defines HOW students use AI during learning:

• When AI is involved (from Pattern Tier 2+), students use AI collaboration patterns (explainer, debugger, pair programmer)
• Balance AI-assisted work with independent verification (40/40/20 model)
• Apply ethical guidelines and verification strategies

In Practice:

1. Book teaches Markdown # headings (Tier 1 - foundational)
   → Students practice manually
   → No AI collaboration patterns needed yet

2. Students learn Markdown tables (Tier 2 - complex syntax)
   → AI companion handles table generation
   → Now apply AI collaboration patterns from this skill:
     - Student specifies table requirements
     - AI generates table
     - Student validates output
     - Student can ask AI to explain syntax (AI as Explainer)

3. Students convert 10 documents (Tier 3 - orchestration)
   → AI orchestrates batch conversion
   → Apply AI pair programming pattern (AI as Pair Programmer)
   → Maintain 40/40/20 balance with verification checkpoints

Key Integration Points:

With 4-Layer Method (Section IIa):

• Layer 1 (Manual practice): Minimal AI collaboration — build independent capability first
• Layer 2-4 (AI-assisted onward): Apply this skill's collaboration patterns

With Graduated Teaching (Principle 2):

• Tier 1 (Foundational): Book teaches directly — minimal AI patterns needed
• Tier 2 (Complex): AI companion handles — apply this skill's collaboration patterns
• Tier 3 (Scale): AI orchestration — full pair programming with strategic oversight

Refer to Section IIa (4-Layer Method) and Principle 2 (Graduated Teaching) for decisions about WHEN and WHAT. Use this skill for HOW students collaborate with AI effectively.

When to Activate

Use this skill when:

• Designing programming courses that integrate AI coding assistants
• Teaching students to use AI tools (ChatGPT, GitHub Copilot, Claude) effectively
• Creating prompt engineering curriculum or exercises
• Establishing policies for AI use in programming education
• Balancing AI assistance with independent skill development
• Assessing whether AI integration enhances or hinders learning
• Educators ask about "AI in teaching", "prompt engineering pedagogy", "AI pair programming", "AI tool literacy"
• Reviewing existing AI-integrated curricula for improvements

Process

Step 1: Understand the Educational Context

When a request comes in to integrate AI into programming education, first clarify:

• What programming topic or course? (Intro to Python, web development, data structures, etc.)
• What is the student level? (Complete beginners, intermediate, advanced)
• What AI tools are available? (ChatGPT, GitHub Copilot, Claude, other)
• What are the learning objectives? (What should students be able to do?)
• What foundational skills must be built independently? (Core concepts that shouldn't use AI)
• What ethical concerns exist? (Academic integrity, over-reliance, attribution)

Step 2: Review Prompt Engineering Pedagogy

Learn how to teach students to craft effective prompts: 📖 reference/prompt-engineering-pedagogy.md

This document covers:

• Four Prompt Competencies: Context setting, constraint specification, output format, iterative refinement
• Teaching Prompt Quality: Clarity, specificity, context completeness, testability
• Scaffolding Strategies: Templates (beginner), critique (intermediate), independent crafting (advanced)
• Common Anti-Patterns: Vague requests, assuming AI knows context, overloading prompts, passive acceptance
• Assessment Strategies: Prompt journals, prompt challenges, peer review

Key Insight: Prompt engineering is about effective communication, problem specification, and critical evaluation - all valuable software engineering skills.

Step 3: Design AI Pair Programming Patterns

Review how students can work with AI as a collaborative partner: 📖 reference/ai-pair-programming-patterns.md

This document covers five patterns:

• Pattern 1: AI as Explainer - Student inquires, AI clarifies concepts
• Pattern 2: AI as Debugger - Student reports bugs, AI helps diagnose
• Pattern 3: AI as Code Reviewer - Student writes code, AI provides feedback
• Pattern 4: AI as Pair Programmer - Student and AI co-create code incrementally
• Pattern 5: AI as Hypothesis Validator - Student forms hypotheses, AI confirms/refutes

Critical Balance: Student should understand and own all code, not just copy-paste AI output.

Teaching Strategies:

• Scaffold from guided templates to independent use
• Require students to explain all code (even AI-generated)
• Include AI-free checkpoints to verify learning
• Balance assistance with independent struggle

Step 4: Build AI Tool Literacy

Teach students to understand AI capabilities and limitations: 📖 reference/ai-tool-literacy.md

This document covers:

• What AI Does Well: Pattern recognition, code generation, explanation, refactoring, debugging common issues
• What AI Does Poorly: Complex domain logic, system design, originality, understanding unstated context, comprehensive security
• Conceptual Understanding: AI is pattern recognition from training data, not logical reasoning
• Verification Strategies: Read/understand, test thoroughly, code review, cross-check documentation, run and observe
• When to Trust: High confidence for well-known patterns, low confidence for security/performance/complex logic
• Recognizing Biases: Recency, popularity, correctness, cultural, representation biases

Key Principle: Trust, but verify - always.

Step 5: Establish Ethical Guidelines

Create clear ethical frameworks for AI use: 📖 reference/ethical-ai-use.md

This document covers seven ethical principles:

1. Honesty and Transparency: Disclose AI assistance
2. Academic Integrity: AI enhances learning, doesn't substitute for it
3. Attribution and Credit: Give credit where due
4. Understanding Over Outputs: Never submit code you don't understand
5. Bias Awareness: Recognize AI limitations and biases
6. Over-Reliance Prevention: Maintain independent coding ability
7. Professional Responsibility: You're accountable for all code

Teaching Strategies:

• Set explicit policies early (Week 1)
• Discuss ethical dilemmas regularly
• Model ethical AI use
• Require process documentation (when/why AI was used)
• Include AI-free assessments periodically

Step 6: Design AI-Integrated Lesson

Use the lesson template to structure AI integration: 📄 templates/ai-lesson-template.yml

The template includes:

• Lesson Metadata: Topic, duration, audience, AI integration level
• Learning Objectives: With AI role specified for each
• Foundational vs. AI-Assisted Skills: What must be learned independently vs. with AI help
• Lesson Phases:
  • Introduction (no AI): Motivation and prerequisites
  • Foundation (no AI): Build core concepts independently first
  • AI-Assisted Exploration (with AI): Practice and explore with scaffolding
  • Independent Consolidation (no AI): Verify learning without AI
  • Wrap-Up: Reflection and discussion
• AI Integration Strategy: Tools, guidelines, prompt templates, disclosure requirements
• Balance Assessment: 40% foundational / 40% AI-assisted / 20% verification (target ratio)
• Ethical Considerations: Policies, prohibited actions, verification requirements

Key Structure: Always start with independent foundation, allow AI assistance with scaffolding, verify learning independently.

Step 7: Create Effective Prompt Templates

Provide students with templates for different tasks: 📄 templates/prompt-design-template.md

This template provides structures for:

• Basic Prompt Structure: Context + Task + Constraints
• Detailed Prompt Template: With focus areas and output format specs
• Task-Specific Templates: Code generation, explanation, debugging, code review, alternatives
• Anti-Patterns: What to avoid
• Prompt Quality Checklist: Verify before submission

Teaching Approach: Start with templates, gradually remove scaffolding as students gain expertise.

Step 8: Assess AI Integration Balance

Once a lesson is designed, validate the AI integration:

python .claude/skills/ai-augmented-teaching/scripts/assess-ai-integration.py lesson-plan.yml

The script assesses:

• ✅ Balance: Is the ratio appropriate (foundation/AI-assisted/verification)?
• ✅ Foundational Skills: Are core skills protected from AI assistance?
• ✅ Verification: Are there checkpoints to test learning without AI?
• ✅ Ethical Guidelines: Are disclosure, understanding, and verification required?

Interpret Results:

• Overall Score: 90+ (Excellent), 75-89 (Good), 60-74 (Needs Improvement), <60 (Poor)
• Balance Issues: Adjust percentages if too much/little AI assistance
• Missing Verification: Add independent checkpoints
• Ethical Gaps: Include disclosure requirements, understanding checks

If score is low:

1. Review recommendations
2. Adjust lesson phases (add independent work or verification)
3. Clarify foundational vs. AI-assisted skills
4. Add ethical guidelines
5. Re-assess until score improves

Step 9: Validate Prompt Quality

For prompt engineering exercises, validate prompt quality:

python .claude/skills/ai-augmented-teaching/scripts/validate-prompts.py prompts.yml

The script checks:

• Clarity: Is the prompt specific and clear?
• Context: Does it provide adequate background?
• Task Specification: Is the requested task explicit?
• Testability: Can the output be verified?
• Constraints: Are requirements and limitations specified?

Interpret Results:

• Quality Score: 85+ (Excellent), 70-84 (Good), 50-69 (Needs Improvement), <50 (Poor)
• Suggestions: Specific improvements for each prompt
• Common Issues: Vague language, missing context, unclear tasks

Use for:

• Evaluating student-written prompts
• Improving prompt templates
• Teaching prompt quality criteria

Step 10: Iterate and Refine

After teaching with AI integration:

1. Gather Feedback: What worked? What didn't?
2. Assess Learning: Did students achieve objectives independently?
3. Check for Over-Reliance: Can students code without AI?
4. Review Ethical Use: Were guidelines followed?
5. Adjust Balance: Increase/decrease AI assistance based on outcomes

Output Format

Present AI-integrated lesson plans following the ai-lesson-template.yml structure:

lesson_metadata:
  title: "Lesson Title"
  topic: "Programming Topic"
  duration: "90 minutes"
  ai_integration_level: "Medium"

learning_objectives:
  - statement: "Students will be able to [action]"
    ai_role: "Explainer | Pair Programmer | Code Reviewer | None"

foundational_skills_focus:
  - "Core skill 1 (no AI)"
  - "Core skill 2 (no AI)"

ai_assisted_skills_focus:
  - "Advanced skill 1 (with AI)"
  - "Advanced skill 2 (with AI)"