aiskillstore/marketplace / skills/92bilal26/learning-objectives
learning-objectives
VerifiedGenerate measurable learning outcomes aligned with Bloom's taxonomy and CEFR proficiency levels for educational content. Use this skill when educators need to define what students will achieve, create learning objectives for curriculum planning, or ensure objectives are specific and testable rather than vague. This skill helps break down complex topics into progressively building learning goals with clear assessment methods and success criteria.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 24.5 KB |
| reference/assessment-methods.md | markdown | 9.6 KB |
| reference/blooms-taxonomy-programming.md | markdown | 7.7 KB |
| reference/prerequisite-analysis.md | markdown | 8.3 KB |
| scripts/validate-objectives.py | script | 8.1 KB |
| skill-report.json | config | 33.2 KB |
| templates/learning-objective-template.yml | config | 3.2 KB |
reference/blooms-taxonomy-programming.md
View on GitHub# Bloom's Taxonomy for Programming Education
## Overview
Bloom's taxonomy defines six cognitive levels that progressively build from simple recall to complex creation. This document adapts these levels specifically for programming education contexts.
---
## Level 1: Remember
**Cognitive Goal**: Recall facts, terminology, and basic concepts
**Definition**: Learners can recall and recognize specific programming terminology, syntax, and foundational concepts without modification.
### Action Verbs (Use These!)
- Recall
- Recognize
- Identify
- Define
- List
- Memorize
- Repeat
- Know
### Programming Examples
- Remember Python built-in functions (len, print, range)
- Recall variable naming conventions
- Identify loop syntax
- List data types in Python
### Assessment Methods
- Multiple choice questions
- Fill-in-the-blank with vocabulary
- Flashcards with definitions
- Term matching exercises
---
## Level 2: Understand
**Cognitive Goal**: Explain ideas or concepts by categorizing, summarizing, generalizing, or inferring
**Definition**: Learners can explain concepts in their own words, interpret code, and understand relationships between ideas.
### Action Verbs (Use These!)
- Explain
- Describe
- Summarize
- Classify
- Interpret
- Infer
- Rephrase
- Translate
- Understand
- Compare
### Programming Examples
- Explain how a for loop iterates
- Describe the difference between lists and tuples
- Summarize what a function does
- Compare class inheritance vs composition
- Interpret error messages
### Assessment Methods
- Explanation essays
- Concept mapping exercises
- Paraphrasing exercises
- Code analysis
- Code walkthroughs (explaining existing code)
---
## Level 3: Apply
**Cognitive Goal**: Use information in new situations (implementing, executing, solving)
**Definition**: Learners can apply programming concepts to solve new problems, write code following examples, and execute known procedures in different contexts.
### Action Verbs (Use These!)
- Apply
- Use
- Implement
- Solve
- Execute
- Demonstrate
- Employ
- Operate
- Practice
- Perform
### Programming Examples
- Write a function to solve a specific problem
- Apply list comprehension to filter data
- Implement a sorting algorithm
- Use object-oriented principles to design a class
- Execute code to get expected output
### Assessment Methods
- Code writing exercises (guided)
- Problem-solving with partial code templates
- Debugging existing code
- Implementing algorithms from pseudocode
- Practical labs with requirements
---
## Level 4: Analyze
**Cognitive Goal**: Draw connections between parts and examine code structure and logic
**Definition**: Learners can break down code/problems into components, identify parts and their relationships, and understand the reasoning behind design choices.
### Action Verbs (Use These!)
- Analyze
- Examine
- Distinguish
- Discriminate
- Identify (patterns)
- Relate
- Infer (causation)
- Deconstruct
- Compare (deeply)
### Programming Examples
- Analyze code to identify performance bottlenecks
- Examine class hierarchy to understand inheritance chains
- Distinguish between different algorithm approaches and their tradeoffs
- Identify design patterns in existing codebase
- Relate test results to code logic
- Explain data structures and their relationships
- Deconstruct complex functions into smaller parts
### Assessment Methods
- Code analysis and annotation exercises
- Design pattern identification
- Algorithm comparison (time/space complexity analysis)
- Debugging exercises where errors must be traced
- Architecture reviews of code organization
- Tradeoff analysis between approaches
---
## Level 5: Evaluate
**Cognitive Goal**: Justify decisions based on criteria and standards
**Definition**: Learners can assess code quality, make judgments about correctness, security, efficiency, or style based on established criteria. They can defend design decisions and identify improvements.
### Action Verbs (Use These!)
- Evaluate
- Assess
- Appraise
- Critique
- Judge
- Justify
- Defend
- Select (based on criteria)
- Verify
- Review
### Programming Examples
- Evaluate code for readability and maintainability
- Assess security vulnerabilities in code
- Judge whether a solution is optimal
- Justify design pattern choices
- Defend architectural decisions
- Critique code style and organization
- Verify test coverage is adequate
- Select the best algorithm for performance constraints
- Review pull requests and suggest improvements
### Assessment Methods
- Code reviews and critique
- Design justification essays
- Peer review assignments
- Security audit exercises
- Test coverage evaluation
- Rubric-based assessment of code quality
- Comparative evaluations of solutions
---
## Level 6: Create
**Cognitive Goal**: Put elements together to form something new; original synthesis
**Definition**: Learners can design new programs, create original solutions, invent algorithms, design architectures, and combine concepts in novel ways. They can identify limitations and extend systems.
### Action Verbs (Use These!)
- Create
- Design
- Build
- Develop
- Construct
- Produce
- Invent
- Compose
- Formulate
- Hypothesize
- Generate
### Programming Examples
- Design and implement a complete application from requirements
- Create a new algorithm to solve a problem
- Develop a library or framework
- Build a data structure for specific use case
- Invent a solution for an ill-defined problem
- Compose modules into larger systems
- Generate test suites for code coverage
- Formulate architectural patterns for scalability
- Hypothesize about code behavior before running it
- Extend existing systems with new features
### Assessment Methods
- Capstone projects
- Open-ended design challenges
- Competitive programming (CodeWars, LeetCode)
- Software development projects with requirements elicitation
- Framework/library creation
- Architecture design assessments
- Portfolio projects demonstrating original work
- Research projects exploring new approaches
---
## Programming Context: Cognitive Load Considerations
When designing learning objectives, consider:
### Remember & Understand (Foundational)
- **Duration**: 20-30% of instruction
- **Load**: Low (basic facts, terminology)
- **Risk**: Overwhelming learners with too much memorization
### Apply (Crucial for Programming)
- **Duration**: 40-50% of instruction
- **Load**: Medium (guided practice)
- **Risk**: Insufficient practice = surface learning
### Analyze, Evaluate, Create (Deep Learning)
- **Duration**: 20-30% of instruction
- **Load**: High (requires synthesis)
- **Risk**: Pushing too fast without foundation = frustration
---
## Design Principle: Avoid Vague Language
❌ **Avoid These Verbs** (ambiguous, unclear):
- Know
- Understand (without context)
- Learn
- Study
- Appreciate
- Get
- Think about
- Be familiar with
- Grasp
- Comprehend
✅ **Use These Instead** (measurable, specific):
- Define (Remember)
- Explain (Understand)
- Apply (Apply)
- Compare (Analyze)
- Evaluate (Evaluate)
- Design (Create)
---
## Example: Building a Learning Objectives Sequence
For teaching **Python Exception Handling**:
1. **Remember**: Define exception and error
2. **Understand**: Explain difference between try/except/finally blocks
3. **Apply**: Write code using try/except for file handling
4. **Analyze**: Examine exception hierarchy and identify appropriate catch blocks
5. **Evaluate**: Assess whether exception handling strategy is adequate for requirements
6. **Create**: Design custom exception classes for domain-specific errors
Each level builds on previous understanding.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 471k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |