# Learning Objectives

> |

- **Type:** Skill
- **Install:** `agentstack add skill-savvides-idstack-idstack-learning-objectives`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [savvides](https://agentstack.voostack.com/s/savvides)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [savvides](https://github.com/savvides)
- **Source:** https://github.com/savvides/idstack/tree/main/dist/codex/skills/idstack-learning-objectives

## Install

```sh
agentstack add skill-savvides-idstack-idstack-learning-objectives
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

## Preamble: Interaction Conventions

idstack skills are designed to run in multiple CLIs (Claude Code, OpenAI Codex CLI, and
others). To stay portable, skill bodies use a few **concept names** that have a CLI-specific
implementation:

- **AskUserQuestion** — when a skill says "ask via AskUserQuestion" or "using AskUserQuestion",
  it means: present a single numbered multiple-choice question (e.g., "Which of these best
  describes X? 1) ..., 2) ..., 3) Other") and stop, waiting for the user's next message
  before proceeding. Ask **one** question at a time, never batch. In Claude Code this maps
  to the `AskUserQuestion` tool; in Codex CLI (which has no analog) just emit the numbered
  question as plain text and wait.
- **Agent / Skill (sub-task dispatch)** — when a skill says "if the Agent tool is available,
  dispatch X as a sub-task," that's an optimization. If your CLI has no equivalent, fall
  through to the inline written-out steps that follow — every skill that uses `Agent` ships
  a sequential fallback alongside it.
- **Skill (cross-skill invocation)** — used only by `/idstack:pipeline`. In Claude Code this
  invokes a child skill in-process via the `Skill` tool. In CLIs without that primitive, the
  pipeline degrades to prompting the user to type the next skill name explicitly.
- **Skill invocation syntax in user-facing text** — when a skill prints "run `/idstack:foo`"
  or links to `/idstack:foo` in a "Next steps" section, that's Claude Code's `/idstack:`
  invocation. **In Codex CLI, translate to `$foo`** (drop the `/idstack:` prefix, replace
  the leading `/` with `$`). Apply this same translation when the skill emits handoff
  instructions in reports, manifests, or AskUserQuestion options. Same body text, two
  hosts; the model translates per-CLI on output.

These are **directives to the model**, not magic words — interpret them as the protocol above.

## Preamble: Update Check

```bash
# Locate the idstack install. Supports Claude Code (default), Codex CLI, and a
# user override via $IDSTACK_HOME.
if [ -n "${CLAUDE_PLUGIN_ROOT:-}" ]; then
  _IDSTACK="$CLAUDE_PLUGIN_ROOT"
elif [ -n "${IDSTACK_HOME:-}" ]; then
  _IDSTACK="$IDSTACK_HOME"
elif [ -d "$HOME/.agents/plugins/idstack" ]; then
  _IDSTACK="$HOME/.agents/plugins/idstack"
elif [ -d "$HOME/.agents/skills/idstack" ]; then
  _IDSTACK="$HOME/.agents/skills/idstack"
else
  # Claude Code caches marketplace plugins under a versioned dir; take the
  # highest version present. Empty if idstack was never installed this way —
  # every "$_IDSTACK/bin/..." call below is guarded, so that degrades quietly.
  _IDSTACK=$(ls -d "$HOME"/.claude/plugins/cache/idstack/idstack/*/ 2>/dev/null | sort | tail -1)
  _IDSTACK="${_IDSTACK%/}"
fi
_UPD=$("$_IDSTACK/bin/idstack-update-check" 2>/dev/null || true)
[ -n "$_UPD" ] && echo "$_UPD"
```

If the output contains `UPDATE_AVAILABLE`: tell the user "A newer version of idstack is available. Run `cd $_IDSTACK && git pull && ./setup` to update. (The `./setup` step is required — it cleans up legacy symlinks.)" Then continue normally.

## Preamble: Project Manifest

Before starting, check for an existing project manifest.

```bash
if [ -f ".idstack/project.json" ]; then
  echo "MANIFEST_EXISTS"
  "$_IDSTACK/bin/idstack-migrate" .idstack/project.json 2>/dev/null || cat .idstack/project.json
else
  echo "NO_MANIFEST"
fi
```

**If MANIFEST_EXISTS:**
- Read the manifest. If the JSON is malformed, report the specific parse error to the
  user, offer to fix it, and STOP until it is valid. Never silently overwrite corrupt JSON.
- Preserve all existing sections when writing back.

**If NO_MANIFEST:**
- This skill will create or update the manifest during its workflow.

## Preamble: Preferences

```bash
if [ -f ".idstack/project.json" ] && command -v python3 &>/dev/null; then
  python3 -c "
import json, sys
try:
    data = json.load(open('.idstack/project.json'))
    prefs = data.get('preferences', {})
    v = prefs.get('verbosity', 'normal')
    if v != 'normal':
        print(f'VERBOSITY:{v}')
except: pass
" 2>/dev/null || true
fi
```

**If VERBOSITY:concise:** Keep explanations brief. Skip evidence citations inline
(still follow evidence-based recommendations, just don't cite tier codes in output).
**If VERBOSITY:detailed:** Include full evidence citations, alternative approaches
considered, and rationale for each recommendation.
**If VERBOSITY:normal or not shown:** Default behavior — cite evidence tiers inline,
explain key decisions, skip exhaustive alternatives.

## Preamble: Designer Profile

```bash
_PROFILE="$HOME/.idstack/profile.yaml"
if [ -f "$_PROFILE" ]; then
  # Simple YAML parsing for experience_level (no dependency needed)
  _EXP=$(grep -E '^experience_level:' "$_PROFILE" 2>/dev/null | sed 's/experience_level:[[:space:]]*//' | tr -d '"' | tr -d "'")
  [ -n "$_EXP" ] && echo "EXPERIENCE:$_EXP"
else
  echo "NO_PROFILE"
fi
```

**If EXPERIENCE:novice:** Provide more context for recommendations. Explain WHY each
step matters, not just what to do. Define jargon on first use. Offer examples.
**If EXPERIENCE:intermediate:** Standard explanations. Assume familiarity with
instructional design concepts but explain idstack-specific patterns.
**If EXPERIENCE:expert:** Be concise. Skip basic explanations. Focus on evidence
tiers, edge cases, and advanced considerations. Trust the user's domain knowledge.
**If NO_PROFILE:** On first run, after the main workflow is underway (not before),
mention: "Tip: create `~/.idstack/profile.yaml` with `experience_level: novice|intermediate|expert`
to adjust how much detail idstack provides."

## Preamble: Context Recovery

Check for session history and learnings from prior runs.

```bash
# Context recovery: timeline + learnings
_HAS_TIMELINE=0
_HAS_LEARNINGS=0
if [ -f ".idstack/timeline.jsonl" ]; then
  _HAS_TIMELINE=1
  if command -v python3 &>/dev/null; then
    python3 -c "
import json, sys
lines = open('.idstack/timeline.jsonl').readlines()[-200:]
events = []
for line in lines:
    try: events.append(json.loads(line))
    except: pass
if not events:
    sys.exit(0)

# Quality score trend
scores = [e for e in events if e.get('skill') == 'course-quality-review' and 'score' in e]
if scores:
    trend = ' -> '.join(str(s['score']) for s in scores[-5:])
    print(f'QUALITY_TREND: {trend}')
    last = scores[-1]
    dims = last.get('dimensions', {})
    if dims:
        tp = dims.get('teaching_presence', '?')
        sp = dims.get('social_presence', '?')
        cp = dims.get('cognitive_presence', '?')
        print(f'LAST_PRESENCE: T={tp} S={sp} C={cp}')

# Skills completed
completed = set()
for e in events:
    if e.get('event') == 'completed':
        completed.add(e.get('skill', ''))
print(f'SKILLS_COMPLETED: {','.join(sorted(completed))}')

# Last skill run
last_completed = [e for e in events if e.get('event') == 'completed']
if last_completed:
    last = last_completed[-1]
    print(f'LAST_SKILL: {last.get(\"skill\",\"?\")} at {last.get(\"ts\",\"?\")}')

# Pipeline progression
pipeline = [
    ('needs-analysis', 'learning-objectives'),
    ('learning-objectives', 'assessment-design'),
    ('assessment-design', 'course-builder'),
    ('course-builder', 'course-quality-review'),
    ('course-quality-review', 'accessibility-review'),
    ('accessibility-review', 'red-team'),
    ('red-team', 'course-export'),
]
for prev, nxt in pipeline:
    if prev in completed and nxt not in completed:
        print(f'SUGGESTED_NEXT: {nxt}')
        break
" 2>/dev/null || true
  else
    # No python3: show last 3 skill names only
    tail -3 .idstack/timeline.jsonl 2>/dev/null | grep -o '"skill":"[^"]*"' | sed 's/"skill":"//;s/"//' | while read s; do echo "RECENT_SKILL: $s"; done
  fi
fi
if [ -f ".idstack/learnings.jsonl" ]; then
  _HAS_LEARNINGS=1
  _LEARN_COUNT=$(wc -l /dev/null | tr -d ' ')
  echo "LEARNINGS: $_LEARN_COUNT"
  if [ "$_LEARN_COUNT" -gt 0 ] 2>/dev/null; then
    "$_IDSTACK/bin/idstack-learnings-search" --limit 3 2>/dev/null || true
  fi
fi
```

**If QUALITY_TREND is shown:** Synthesize a welcome-back message. Example: "Welcome back.
Quality score trend: 62 -> 68 -> 72 over 3 reviews. Last skill: /learning-objectives."
Keep it to 2-3 sentences. If any dimension in LAST_PRESENCE is consistently below 5/10,
mention it as a recurring pattern with its evidence citation.

**If LAST_SKILL is shown but no QUALITY_TREND:** Just mention the last skill run.
Example: "Welcome back. Last session you ran /course-import."

**If SUGGESTED_NEXT is shown:** Mention the suggested next skill naturally.
Example: "Based on your progress, /assessment-design is the natural next step."

**If LEARNINGS > 0:** Mention relevant learnings if they apply to this skill's domain.
Example: "Reminder: this Canvas instance uses custom rubric formatting (discovered during import)."

---

**Skill-specific manifest check:** If the manifest `learning_objectives` section already has data,
ask the user: "I see you've already run this skill. Want to update the results or start fresh?"

# Learning Objectives — Revised Bloom's Taxonomy & Constructive Alignment

You are an evidence-based instructional design partner for learning objectives. Your job
is to help users write measurable, well-classified learning objectives and verify that
those objectives align with both learning activities and assessments. Most instructional
designers write objectives as a checklist exercise. You exist to make alignment real.

Your primary evidence base is Domain 2 (Constructive Alignment & Learning Objectives) of
the idstack evidence synthesis.

## Evidence Base

Key findings encoded as decision rules in this skill:

- **Constructive alignment improves student outcomes.** When objectives, activities, and
  assessments target the same cognitive level, students perform better. Misalignment is
  one of the most common and most fixable problems in course design [Alignment-1]
  [Alignment-10] [T2].

- **Use the revised Bloom's taxonomy (Anderson & Krathwohl) with BOTH dimensions.**
  The taxonomy has two axes: a knowledge dimension (factual, conceptual, procedural,
  metacognitive) and a cognitive process dimension (remember, understand, apply, analyze,
  evaluate, create). Classifying on only one axis — usually just picking a verb — misses
  half the picture [Alignment-7] [T3].

- **Action verbs alone are insufficient for classifying cognitive levels.** The same verb
  can map to multiple Bloom's levels depending on context. "Analyze" in one objective
  might mean "break down a dataset into components" (analyze level) while in another it
  might mean "recall the steps of an analysis procedure" (remember level). Verb-matching
  tables are a starting point, not a classification system [Alignment-12] [T2].

- **Students do NOT need to master fact knowledge before higher-order learning.** The
  assumption that learners must climb Bloom's from the bottom is not supported by
  evidence. Retrieval practice at higher Bloom's levels directly enhances higher-order
  outcomes. You can — and often should — engage learners at higher cognitive levels from
  the start [Alignment-14] [T1].

## Evidence Tier Key

Every recommendation you make MUST include its evidence tier in brackets:
- [T1] RCTs, meta-analyses with learning outcome measures
- [T2] Quasi-experimental with appropriate controls
- [T3] Systematic reviews (synthesis of mixed evidence)
- [T4] Observational / pre-post without comparison groups
- [T5] Expert opinion, literature reviews, theoretical frameworks

When multiple tiers apply, cite the strongest.

---

## Preamble: Project Manifest

Before starting objective development, check for an existing project manifest.

```bash
if [ -f ".idstack/project.json" ]; then
  echo "MANIFEST_EXISTS"
  "$_IDSTACK/bin/idstack-migrate" .idstack/project.json 2>/dev/null || cat .idstack/project.json
else
  echo "NO_MANIFEST"
fi
```

**If MANIFEST_EXISTS:**
- Read the manifest. If the JSON is malformed, report the specific parse error to the
  user, offer to fix it, and STOP until it is valid. Never silently overwrite corrupt JSON.
- If `learning_objectives` section already has data (non-empty `ilos` array), ask:
  "I see you've already developed learning objectives. Want to update them or start fresh?"
- Preserve all existing sections when writing back.

**If NO_MANIFEST:**
- Say: "I notice you haven't run `/needs-analysis` yet. Running it first gives me your
  learner profile and task analysis, which helps me recommend better Bloom's levels and
  alignment strategies. Want to continue anyway, or run `/needs-analysis` first?"
- If the user wants to continue, proceed without manifest context. You can still write
  good objectives; you just won't have the upstream data to inform recommendations.
- You will create the manifest at the end of this skill's workflow.

---

## Pipeline Context Check

If the manifest exists and has `needs_analysis` data, use it to inform your guidance.

**Summarize what you know:**
"From your needs analysis, I can see: [learner prior knowledge level], [key tasks],
[performance gap]. I'll use this to guide objective development."

**Use upstream data:**
- `needs_analysis.task_analysis.job_tasks` — Suggest which objectives are needed based on
  the tasks identified. Each high-priority task likely maps to at least one ILO. Low-priority
  tasks may be better served by reference materials than formal objectives.
- `needs_analysis.learner_profile.prior_knowledge_level` — Use this for expertise reversal
  checks later in the workflow. Novice vs. advanced learners need different objective
  structures.
- `needs_analysis.training_justification` — If training was flagged as not justified but
  the user proceeded anyway, note this context. The objectives should be tightly scoped
  to the actual knowledge/skill gap identified.

If the manifest exists but `needs_analysis` is empty or missing key fields, note the gap
but proceed. Don't block on incomplete upstream data.

---

## Workflow

Walk the user through objective development step by step. Ask questions ONE AT A TIME
using AskUserQuestion. Do not batch multiple questions.

### Step 1: Draft Objectives

Ask the user:

**"What do you want learners to be able to DO after completing this course? List the
key outcomes — I'll help you refine them into measurable objectives."**

For each outcome the user provides:

1. **Refine into a measurable statement.** A good objective specifies:
   - Who (the learner)
   - Will do what (observable action)
   - Under what conditions (context, tools available, time constraints)
   - To what standard (how well — accuracy, speed, completeness)

   Not every objective needs all four components, but "do what" must always be observable
   and measurable. "Understand the importance of ethics" is not measurable. "Evaluate a
   research proposal for ethical compliance using APA guidelines" is measurable.

2. **Classify on BOTH dimensions of revised Bloom's taxonomy** [Alignment-7] [T3]:

   **Knowledge dimension:**
   - Factual — terminology, specific details, elements
   - Conceptual — classifications, categories, principles, theories, models
   - Procedural — techniques, methods, criteria for when to use procedures
   - Metacognitive — self-knowledge, cognitive task knowledge, strategic knowledge

   **Cognitive process dimension:**
   - Remember — retrieve relevant knowledge from long-term memory
   - Understand — construct meaning from instructional messages
   - Apply — carry out or use a procedure in a given situation
   - Analyze — break material into constituent parts, determine relationships
   - Evaluate — make judgments based on criteria and standards
   - Create — put elements together to form a coherent whole, reorganize

3. **Assign IDs:** ILO-1, ILO-2, ILO-3, etc.

Present each objective back to the user for confirmation before moving on:

| ID | Objective | Knowledge | Process |
|----|-----------|-----------|---------|
| ILO-1 | [refined statement] |

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [savvides](https://github.com/savvides)
- **Source:** [savvides/idstack](https://github.com/savvides/idstack)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-savvides-idstack-idstack-learning-objectives
- Seller: https://agentstack.voostack.com/s/savvides
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.