aiskillstore/marketplace / skills/92bilal26/ai-collaborate-teaching
ai-collaborate-teaching
VerifiedDesign co-learning experiences using the Three Roles Framework (AI as Teacher/Student/Co-Worker). Use when teaching AI-driven development workflows, spec-first collaboration, or balancing AI assistance with foundational learning. NOT for curriculum without AI integration.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 7.6 KB |
| reference/ai-pair-programming-patterns.md | markdown | 19.2 KB |
| reference/ai-tool-literacy.md | markdown | 18.9 KB |
| reference/ethical-ai-use.md | markdown | 19.2 KB |
| reference/prompt-engineering-pedagogy.md | markdown | 16.8 KB |
| scripts/assess-ai-integration.pyexecutable | script | 13.1 KB |
| scripts/validate-prompts.pyexecutable | script | 13.7 KB |
| skill-report.json | config | 49.5 KB |
| templates/ai-lesson-template.yml | config | 13.2 KB |
| templates/prompt-design-template.md | markdown | 12.5 KB |
reference/ethical-ai-use.md
View on GitHub# Ethical AI Use in Programming Education
## Overview
This document provides guidance for teaching students to use AI coding assistants ethically and responsibly. It covers attribution, academic integrity, bias awareness, over-reliance prevention, and professional responsibility when using AI in software development.
---
## Core Ethical Principles for AI-Assisted Learning
### Principle 1: Honesty and Transparency
**Core Idea**: Be honest about AI assistance. Don't pass off AI work as your own independent effort.
---
#### In Academic Settings
**Scenario**: Student uses AI to help with homework
**Unethical** ❌:
- Uses AI to generate solution
- Submits as own work without mentioning AI
- Claims full credit for work they didn't fully create
**Ethical** ✅:
- Discloses AI usage according to course policy
- Clearly marks AI-generated vs. student-written code
- Explains their own contributions and learning
**Teaching**: Help students understand that honesty about AI use is non-negotiable, just like citing sources in research.
---
#### In Professional Settings
**Scenario**: Developer uses AI to complete work task
**Unethical** ❌:
- Copies AI code without reviewing or understanding
- Doesn't inform team about AI-generated code
- Takes credit for AI's work in performance reviews
**Ethical** ✅:
- Reviews and tests AI-generated code thoroughly
- Documents AI assistance where relevant
- Shares AI-accelerated productivity benefits with team
- Takes responsibility for code quality regardless of origin
**Teaching**: Emphasize professional responsibility. Even if AI wrote it, the developer is accountable.
---
### Principle 2: Academic Integrity
**Core Idea**: AI should enhance learning, not substitute for it. Using AI to bypass learning is cheating yourself.
---
#### Understanding vs. Using
**Unethical Use** ❌:
```
Exam Question: "Write a function to implement quicksort"
Student: [Asks AI for solution, copies directly]
Result: No learning occurred. Student can't implement quicksort independently.
```
**Ethical Use** ✅:
```
Homework: "Implement quicksort"
Student:
1. Attempts independently (struggles, makes progress)
2. After significant effort, asks AI for help with specific stuck point
3. Studies AI explanation
4. Rewrites solution in own words to demonstrate understanding
5. Can explain how quicksort works
```
**Key Difference**: Struggle and understanding came first. AI assisted learning, didn't replace it.
---
#### When AI Assistance is Appropriate
**✅ Appropriate**:
- Explaining concepts after you've attempted to understand
- Debugging after you've tried to find the bug
- Generating test cases after you've written some
- Exploring alternative approaches after you've implemented one
- Learning new libraries/frameworks (not core concepts)
- Getting unstuck after significant independent effort
**❌ Inappropriate**:
- Getting answers before attempting problems
- Completing graded assessments (unless explicitly allowed)
- Bypassing learning opportunities
- Using AI for tasks you should be able to do independently
- Submitting AI work as own without understanding
---
#### Teaching Academic Integrity with AI
**Strategy 1: The "Can You Do This Without AI?" Test**
Periodically assess students without AI access:
- In-class coding exercises
- Live coding interviews
- Timed challenges
- Pair programming sessions
**Purpose**: Ensure AI-assisted learning translates to independent capability.
---
**Strategy 2: Process Over Product**
Grade based on:
- Learning process documentation (how they used AI, what they learned)
- Ability to explain all code (including AI-generated)
- Independent problem-solving in follow-up exercises
- Depth of understanding, not just working code
**Purpose**: Incentivize learning, not just task completion.
---
**Strategy 3: Explicit Policy Setting**
Create clear AI use policies for courses:
**Example Policy**:
```
AI Use Guidelines for This Course:
Allowed:
- Using AI to explain concepts after lecture
- Asking AI for debugging help after 20+ minutes of effort
- Generating test cases or examples
- Code review and style suggestions
- Exploring alternative approaches after completing one
Require Disclosure:
- Document when and how you used AI (in comments or reflection)
- Explain what you learned from AI assistance
- Demonstrate understanding by explaining AI-generated code
Not Allowed:
- Using AI for exam questions
- Submitting AI code without understanding it
- Getting solutions before attempting problems yourself
- Using AI to complete entire assignments
Consequences:
- Using AI without disclosure: Academic integrity violation
- Using AI for exams: Zero on exam
- Repeated violations: Course failure and disciplinary action
```
**Teaching**: Discuss policy on day one. Explain rationale. Answer questions.
---
### Principle 3: Attribution and Credit
**Core Idea**: Give credit where it's due. This includes AI assistance.
---
#### Code Comments and Attribution
**When to Attribute**:
- AI generated substantial code (more than a few lines)
- AI provided the algorithm or approach
- AI suggested non-obvious solution
**How to Attribute**:
```python
def binary_search(arr, target):
"""
Binary search implementation.
Algorithm structure generated with AI assistance (Claude, 2025-01-15).
Modified by [Student Name] to add edge case handling.
"""
# AI-generated initial implementation
left, right = 0, len(arr) - 1
while left <= right:
mid = (left + right) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
# Student addition: handle empty array case
return -1
```
**Teaching**: Model attribution in your own examples. Make it a habit.
---
#### Project Documentation
For larger projects, include an "AI Assistance Statement":
```
## AI Assistance Disclosure
AI tools used: Claude (Anthropic), GitHub Copilot
Areas of assistance:
- Initial project scaffolding (file structure, imports)
- Debugging file I/O error in data_loader.py (lines 45-60)
- Generating test cases for validate_input() function
- Code review suggestions for improved readability
All AI-generated code was reviewed, tested, and modified where necessary.
I can explain and justify all code in this project.
```
**Teaching**: Require this for all major projects. Review as part of grading.
---
### Principle 4: Understanding Over Outputs
**Core Idea**: The goal is learning, not just getting working code. Prioritize understanding.
---
#### The Understanding Contract
Students should commit to:
- **Never submit code I don't understand**
- **Always test and verify AI code**
- **Explain every line if asked**
- **Maintain ability to code without AI**
**Teaching Activity**: "Code Walkthrough"
- Student submits project
- Instructor asks: "Explain this function. Why does it work this way?"
- Student must explain clearly, including AI-generated parts
- If student can't explain, grade reflects lack of understanding
**Purpose**: Creates accountability for understanding, not just completion.
---
#### Learning Checkpoints
Periodically require students to:
1. Solve similar problems without AI
2. Extend AI-generated code independently
3. Debug AI code that has subtle errors
4. Explain concepts to peers
**Purpose**: Verify that AI-assisted learning results in retained knowledge and skills.
---
### Principle 5: Bias Awareness
**Core Idea**: AI reflects biases in training data. Students must recognize and mitigate these biases.
---
#### Types of AI Bias Students Should Know
**1. Correctness Bias**
- AI learned from public code, including buggy code
- Popular doesn't mean correct
**Teaching**: Show examples of widely-copied-but-wrong Stack Overflow answers
---
**2. Recency Bias**
- AI training data has cutoff date
- May not know latest best practices or library versions
**Teaching**: Have students verify AI suggestions against current documentation
---
**3. Popularity Bias**
- AI favors common patterns over niche solutions
- Mainstream libraries over specialized tools
**Teaching**: Discuss when specialized tools are better despite AI not suggesting them
---
**4. Cultural Bias**
- AI performs better with English prompts
- Examples and metaphors may assume Western context
- Variable naming conventions may be English-centric
**Teaching**: Acknowledge this limitation. Encourage students from other cultures to share experiences.
---
**5. Representation Bias**
- AI training data may underrepresent certain languages, frameworks, or paradigms
- Newer or less common technologies may have lower-quality AI suggestions
**Teaching**: When working with cutting-edge or niche tech, verify more thoroughly
---
#### Teaching Bias Awareness
**Activity 1: Bias Hunt**
Give students AI-generated code. Have them identify potential biases:
- Is this the only approach? (Popularity bias)
- Is this current? (Recency bias)
- Does this work for all contexts? (Cultural bias)
- Is this actually correct? (Correctness bias)
**Activity 2: Comparative Analysis**
Ask AI and consult official documentation. Compare:
- What does AI suggest?
- What do official docs recommend?
- What are the differences?
- Why might they differ?
---
### Principle 6: Over-Reliance Prevention
**Core Idea**: AI is a tool, not a crutch. Students must maintain independent coding ability.
---
#### Signs of Over-Reliance
**Warning Signs**:
- Can't write simple code without AI
- Immediately reaches for AI on every problem
- Panics when AI is unavailable
- Can't debug without AI assistance
- Doesn't remember concepts learned with AI's help
**Teaching**: Monitor for these signs. Intervene early.
---
#### Strategies to Prevent Over-Reliance
**Strategy 1: AI-Free Time**
Designate periods where AI is not allowed:
- In-class exercises
- Timed challenges
- Pair programming sessions
- Weekly "fundamentals practice"
**Purpose**: Build and maintain independent skills.
---
**Strategy 2: The 20-Minute Rule**
Students must attempt problems independently for 20 minutes before using AI.
**Purpose**: Ensure struggle and independent problem-solving happen first.
---
**Strategy 3: Progressive Independence**
Early in course: AI allowed for most tasks
Mid-course: AI allowed after attempt and struggle
Late in course: AI only for advanced/new topics
**Purpose**: Scaffold independence. Gradually reduce AI dependency.
---
**Strategy 4: Metacognitive Reflection**
Students regularly reflect:
- "What did I learn this week that I can do without AI?"
- "What tasks am I still dependent on AI for?"
- "Am I using AI as a learning tool or a crutch?"
**Purpose**: Build self-awareness about AI dependency.
---
### Principle 7: Professional Responsibility
**Core Idea**: In professional settings, you're responsible for all code, regardless of origin.
---
#### Responsibility Scenarios
**Scenario 1: Security**
```
Developer uses AI to generate authentication code.
Code has subtle security vulnerability.
System is hacked. Customer data stolen.
Who's responsible? The developer, not the AI.
```
**Lesson**: You're accountable for code quality and security, even if AI wrote it.
---
**Scenario 2: Legal Compliance**
```
Developer uses AI to generate data processing code.
Code violates GDPR (European privacy law).
Company faces fines.
Who's responsible? The developer, not the AI.
```
**Lesson**: You must ensure code complies with laws and regulations. AI doesn't understand legal requirements.
---
**Scenario 3: Licensing**
```
Developer uses AI to generate code.
Code closely resembles GPL-licensed code (copyleft).
Company's proprietary code now has licensing issues.
Who's responsible? The developer, not the AI.
```
**Lesson**: AI training data included open-source code. Generated code may have licensing implications. You must review and understand licenses.
---
#### Teaching Professional Responsibility
**Activity: Case Study Analysis**
Present real or hypothetical scenarios where AI-generated code causes problems:
- Security breaches
- Data loss
- Legal violations
- Production failures
**Discussion**:
- Who is responsible?
- How could this have been prevented?
- What verification was needed?
**Lesson**: Professional developers are always accountable for code they deploy.
---
## Teaching Strategies for Ethical AI Use
### Strategy 1: Early and Explicit Discussion
**Week 1 of Course**:
- Discuss AI use explicitly
- Share course policy
- Explain rationale (why these rules exist)
- Answer questions
- Model ethical use in examples
**Purpose**: Set expectations and norms early.
---
### Strategy 2: Ethical Dilemma Discussions
Present scenarios. Students discuss and debate:
**Scenario A**:
"You're stuck on a homework problem. You've spent 10 minutes on it. Is it ethical to ask AI for the solution?"
**Discussion Points**:
- 10 minutes enough struggle?
- What would you learn from AI solution?
- Could you ask for a hint instead of full solution?
---
**Scenario B**:
"You use AI to help with a project. How much detail should you include in your AI assistance disclosure?"
**Discussion Points**:
- Is 'I used AI' enough?
- Should you specify which parts?
- How much detail is appropriate?
---
### Strategy 3: Reflection Assignments
Require students to reflect on AI use:
**Weekly Reflection Prompts**:
- How did I use AI this week?
- Did AI help me learn, or did it substitute for learning?
- What did I learn that I can now do without AI?
- Did I maintain ethical standards in my AI use?
**Purpose**: Build metacognitive awareness of AI use patterns.
---
### Strategy 4: Positive Framing
Don't just prohibit AI use. Explain how to use AI ethically and effectively.
**Instead of**: "Don't use AI to cheat"
**Better**: "Use AI to accelerate learning after you've attempted problems independently"
**Purpose**: Guide students toward productive AI use, not just away from misuse.
---
## Assessment Approaches for Ethical Use
### Assessment 1: Ethical Use Quiz
Test understanding of ethical principles:
**Sample Questions**:
1. You're stuck on a problem after 5 minutes. Is it ethical to ask AI for the full solution? Why or why not?
2. You use AI to generate 30% of your project code. How should you disclose this?
3. AI generates code with a security vulnerability. Who is responsible?
4. True/False: If AI generates code, you don't need to understand it as long as it works.
**Purpose**: Check comprehension of ethical standards.
---
### Assessment 2: Process Documentation
Students document their development process:
- When they used AI
- Why they used AI (what were they trying to achieve?)
- What they learned
- How they verified AI outputs
**Grading**: Based on thoughtful, ethical use of AI as a learning tool.
---
### Assessment 3: Code Explanation
Students must explain all code, including AI-generated:
- Verbal walkthrough
- Written explanation
- Live debugging or extension
**Purpose**: Verify understanding. If students can't explain it, they don't understand it.
---
## Common Ethical Challenges and Guidance
### Challenge 1: "Everyone Else Uses AI Without Disclosure" 🤷
**Student Argument**: "If everyone cheats, why shouldn't I?"
**Response**:
- Integrity is about your values, not others' behavior
- Not everyone cheats (confirmation bias)
- Short-term gains, long-term skill deficit
- Professional reputation built on honesty
- You're competing with yourself (learning), not others
**Teaching**: Emphasize intrinsic motivation and long-term consequences.
---
### Challenge 2: "I'm Under Time Pressure" ⏰
**Student Argument**: "I don't have time to struggle. I need to finish fast."
**Response**:
- Time management is a skill (plan better)
- Struggle is where learning happens (shortcuts = no learning)
- Start assignments earlier
- Seek help from instructor/peers if truly stuck
- Real-world jobs also have time pressure - build skills now
**Teaching**: Provide time management resources. Offer office hours for help.
---
### Challenge 3: "AI Just Speeds Me Up" 🏃
**Student Argument**: "I understand everything. AI just makes me faster."
**Response**:
- Prove it: Solve similar problem without AI
- If you truly understand, you don't need AI for fundamentals
- Speed without understanding = fragile knowledge
- Periodic AI-free assessments verify understanding
**Teaching**: Regularly assess without AI. If student performs equally well, they're right. If not, they're over-reliant.
---
### Challenge 4: "The Job Market Uses AI Anyway" 💼
**Student Argument**: "Everyone uses AI at work. Why not in school?"
**Response**:
- True: AI is a professional tool
- But: Professionals use AI from a foundation of knowledge
- School builds that foundation
- Professionals verify AI outputs rigorously (can you?)
- Learning to use AI effectively requires understanding code first
**Teaching**: Agree AI is important. But emphasize learning comes first, then AI amplifies those skills.
---
## Summary: Core Values for Ethical AI Use in Education
1. **Honesty**: Always disclose AI assistance honestly
2. **Integrity**: AI should enhance learning, not replace it
3. **Attribution**: Give credit to AI when appropriate
4. **Understanding**: Never use code you don't understand
5. **Awareness**: Recognize AI biases and limitations
6. **Independence**: Maintain ability to code without AI
7. **Responsibility**: You're accountable for all code, AI-generated or not
8. **Fairness**: Use AI in ways that align with course policies and learning goals
9. **Growth**: Focus on long-term skill development, not short-term task completion
10. **Transparency**: Document and reflect on AI use openly
---
## Creating a Culture of Ethical AI Use
### Instructor Modeling
**Teachers should**:
- Model ethical AI use in examples
- Discuss their own AI use openly
- Show verification processes
- Demonstrate critical evaluation
- Admit when AI helps vs. hinders
**Purpose**: Normalize ethical use. Students follow examples.
---
### Peer Accountability
**Encourage students to**:
- Discuss AI use with peers
- Share strategies for effective use
- Hold each other accountable
- Report concerning patterns (not individuals, but trends)
**Purpose**: Build community standards for AI use.
---
### Continuous Dialogue
**Keep discussing AI use throughout course**:
- Not just a Week 1 lecture
- Revisit as students gain experience
- Discuss edge cases as they arise
- Adapt policies based on what's working
**Purpose**: Maintain awareness and engagement with ethical issues.
---
**Key Insight**: Ethical AI use isn't about prohibiting AI. It's about using AI in ways that enhance learning, maintain integrity, and build long-term skills. The goal is responsible, thoughtful AI integration that serves students' educational goals, not shortcuts around them.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |