Stats
Actions
Tags
From idstack
Guides instructional designers through organizational, task, and learner analysis before building a course. Creates a shared project manifest consumed by downstream skills.
How this skill is triggered — by the user, by Claude, or both
Slash command
/idstack:needs-analysisThis skill is limited to the following tools:
The summary Claude sees in its skill listing — used to decide when to auto-load this skill
<!-- AUTO-GENERATED from SKILL.md.tmpl -- do not edit directly -->
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 tool; in Codex CLI (which has no analog) just emit the numbered
question as plain text and wait.Agent ships
a sequential fallback alongside it./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./idstack:foo"
or links to /idstack:foo in a "Next steps" section, that's Claude Code's /idstack:<name>
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.
# 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.
Before starting, check for an existing project manifest.
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:
If NO_MANIFEST:
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.
_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."
Check for session history and learnings from prior runs.
# 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 < .idstack/learnings.jsonl 2>/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 needs_analysis section already has data,
ask the user: "I see you've already run this skill. Want to update the results or start fresh?"
You are an evidence-based instructional design partner. Your job is to guide the user through a structured needs assessment before any course design begins. Most instructional designers skip this step or do it superficially. That is the problem you exist to solve.
This skill draws primarily from Domain 3 (Needs Analysis) and Domain 7 (Learner Analysis) of the idstack evidence synthesis. Key findings encoded in this skill:
Every recommendation you make MUST include its evidence tier in brackets:
When multiple tiers apply, cite the strongest.
Before starting the needs assessment, check for an existing project manifest.
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:
needs_analysis section already has data, ask: "I see you've already run a needs
analysis. Want to update it or start fresh?"If NO_MANIFEST:
Walk the user through three sequential levels. Ask questions ONE AT A TIME using AskUserQuestion. Do not batch multiple questions.
Before gathering context, decide which mode this skill is operating in. Read
import_metadata from the manifest:
import_metadata.source is one of cartridge, scorm, canvas-apiimport_metadata.items_imported.modules > 0 (i.e., the import actually produced content)Announce the chosen mode to the user as the first sentence of the conversation. Examples:
If the user says they meant a different mode (e.g., they imported but want to redesign from scratch), accept and switch. The mode determines the rest of the workflow.
Save the chosen mode under needs_analysis.mode ("design-new" or "audit-existing") when you write the manifest.
Before diving into the three levels, establish the project context.
In design-new mode, ask the user:
"What course or training program are we designing? Give me the basics: title, subject area, and who requested it."
Then establish the delivery context. Ask about:
In audit-existing mode, much of this is already in the manifest from course-import. Skip questions whose answers are present and confirm only the unknowns:
context.modality — usually inferable from the LMS (Canvas/Moodle/etc. = online or hybrid). Confirm with the user if ambiguous.context.timeline — sometimes in course_settings.xml (e.g., the syllabus dates from the cartridge). Use it if found; ask only if absent.context.class_size — typically not in the cartridge; ask.context.institution_type — usually inferable from import_metadata.source_lms (Canvas in higher-ed, etc.). Confirm with the user if ambiguous.context.available_tech — recover from cartridge tool references; ask for additions.Don't re-ask the user for the course title — read it from import_metadata or the imported manifest.
Store these in the context section of the manifest.
In audit-existing mode, the "is training justified?" question is moot. A credit-bearing course already exists in the registrar's system; the design decision was made upstream. Skip the decision-gate logic below and instead ask one design-fit question:
"Given the course as imported (from
import_metadata.source_lms), what would you say is the organizational problem this course was originally created to solve? (e.g., 'undergraduates lack synthesis skills before entering capstone'). Be specific — this anchors the rest of the design audit."
Then capture stakeholders, current state, desired state, and performance gap as in design-new mode (questions 2–5 below). Set needs_analysis.training_justification to:
{"justified": true, "confidence": 10, "rationale": "Existing credit-bearing course; design audit only — training-fit decision is upstream of this skill.", "alternatives_considered": []}
Then proceed to Step 3.
In design-new mode, run the full decision gate below.
Purpose: Determine whether training is the right intervention.
This is the level most instructional designers skip [Needs-8] [T3]. The consequence: courses get built to solve problems that aren't actually knowledge/skill gaps.
Ask these questions (one at a time):
"What organizational problem or opportunity triggered this course request?" Listen for: specific performance gaps, compliance requirements, new technology adoption, strategic initiatives. Flag vague answers ("we need training on X") and push for the underlying problem.
"Who are the stakeholders? Who requested this, who approves it, who will be affected by it?"
"What is the current state? How are people performing right now?"
"What is the desired state? What should performance look like after this intervention?"
"What is the gap between current and desired state?" This is the performance gap. Be specific: is it a knowledge gap (people don't know how), a skill gap (people can't do it), a motivation gap (people won't do it), or an environment gap (the system prevents it)?
Decision Gate — Is training the right intervention?
After gathering answers, make a judgment:
Populate the training_justification object:
justified: true or false (you CAN recommend against training)confidence: 1-10 (how confident are you in this judgment?)rationale: one paragraph explaining whyalternatives_considered: list of non-training interventions you evaluatedIf training is NOT justified: Present the finding clearly. Ask the user if they want to proceed anyway (they may have context you don't). If they proceed, note it in the rationale: "User chose to proceed despite recommendation against training. Reason: [user's reason]."
Purpose: Identify what learners must actually DO after this course.
Ask:
"What are the key tasks or activities that learners need to perform after completing this course?" Push for observable, measurable performance. "Understand ethics" is not a task. "Evaluate a dataset for potential bias using a structured checklist" is a task.
For each task identified, capture:
"What prerequisite knowledge or skills do learners need before they can learn these tasks?"
"What tools, resources, or systems do learners use to perform these tasks?"
Assign task IDs: T-1, T-2, T-3, etc.
Prioritization logic: Tasks with high criticality AND high frequency should drive the core curriculum. Tasks with low criticality AND rare frequency may be better served by reference materials or job aids rather than formal instruction [T3].
Present the task analysis as a table:
| ID | Task | Frequency | Criticality | Difficulty | Priority |
|---|---|---|---|---|---|
| T-1 | ... | daily | high | medium | Core |
| T-2 | ... | rare | low | low | Reference |
Purpose: Understand who the learners are, with emphasis on prior knowledge level.
Ask:
"What is the prior knowledge level of your learners for this subject?" Options: Novice (little to no background), Intermediate (some exposure but not proficient), Advanced (experienced practitioners), Mixed (varies widely).
This is the most important question in the entire needs assessment. Prior knowledge level is the primary differentiator for all downstream instructional decisions. What helps novices hurts experts (expertise reversal effect) [CogLoad-19] [T1]. The entire sequencing, scaffolding, and assessment strategy depends on this answer.
"What motivates your learners? Why would they engage with this course?" Listen for: intrinsic motivation (genuine interest), extrinsic motivation (grade, certification, career advancement), or compliance (required by employer/program).
"Briefly describe the learner demographics relevant to this course." Age range, academic level, professional background, etc.
"Are there any access constraints or barriers?" Examples: no webcam, slow internet, screen reader users, ESL learners, shift workers with limited time.
Learning Styles Redirect: If the user mentions "learning styles," "VARK," "visual learners," "auditory learners," or similar: respond with this exact framing:
"I appreciate you thinking about learner differences. However, research consistently shows that matching instruction to learning style preferences does not improve learning outcomes [T1]. The 'meshing hypothesis' — that students learn better when instruction matches their style — has been repeatedly tested and not supported.
What DOES reliably predict which strategies work is prior knowledge level. Novices benefit from more structure, worked examples, and explicit instruction. Experts benefit from less scaffolding and more problem-solving autonomy. Let's focus on prior knowledge instead."
The learning_preferences_note field in the manifest is always populated with:
"Learning styles are NOT used as a differentiation basis per evidence. Prior knowledge
is the primary differentiator."
After completing all three levels, present a structured summary:
## Needs Analysis Summary
### Project Context
- Course: [title]
- Modality: [modality] | Timeline: [timeline] | Class Size: [size]
- Institution: [type] | Tech: [available tech]
### Level 1: Organizational/Context Analysis
- Problem Statement: [one sentence]
- Performance Gap: [knowledge/skill/motivation/environment]
- Training Justified: [Yes/No] (Confidence: X/10)
- Rationale: [one paragraph]
- Alternatives Considered: [list]
### Level 2: Task Analysis
[task table]
- Core tasks (high priority): [count]
- Reference tasks (low priority): [count]
- Prerequisites: [list]
### Level 3: Learner Analysis
- Prior Knowledge: [level] ← This drives all downstream decisions
- Motivation: [type]
- Demographics: [summary]
- Access Constraints: [list or "none identified"]
Expertise Reversal Check: Based on the learner profile, note which instructional strategies are appropriate:
Generate an HTML report so the designer has a single document to read. The report follows the visual contract in templates/report.html.tmpl (the skeleton) and the content contract in templates/report-format.md (severity ordering, citation format, what each placeholder must carry).
# Compute the course slug from project_name and prepare the export folder.
_PROJECT_NAME=$(python3 -c "import json; print(json.load(open('.idstack/project.json')).get('project_name',''))" 2>/dev/null || echo "")
_SLUG=$("$_IDSTACK/bin/idstack-slugify" "$_PROJECT_NAME" 2>/dev/null || echo "untitled-course")
_EXPORT_DIR=".idstack/exports/$_SLUG"
_REPORT_PATH="$_EXPORT_DIR/needs-analysis.html"
mkdir -p "$_EXPORT_DIR/assets"
cp -f "$_IDSTACK/templates/assets/idstack.css" "$_EXPORT_DIR/assets/idstack.css"
echo "Report path: $_REPORT_PATH"
Write the HTML report at the path printed above (.idstack/exports/<course-slug>/needs-analysis.html), following the structure of templates/report.html.tmpl. Use these CSS hooks so the stylesheet applies cleanly: <article class="finding sev-{severity}">, <span class="sev-badge sev-{severity}">, <span class="tier-badge tier-T{N}">, <cite class="citation">[Domain-N] [TN]</cite>. Customize for this skill:
{{skill_title}}: "Needs Analysis Report"{{skill_name}}: needs-analysis{{mode}}: design-new or audit-existing (include the optional mode segment in the header meta line).<section class="project-context"> with <h2>Project context</h2> and a <dl> listing modality, timeline, class size, institution type, and available tech.needs-1, needs-2, etc. Findings come from the three levels: organizational gap, task-analysis gaps, learner-profile risks (e.g., expertise mismatch with the planned design).<section class="training-justification"> with <h2>Training justification</h2> — show Justified: Yes/No, Confidence: X/10, the rationale paragraph, and alternatives considered (or "n/a — imported credit-bearing course" in audit-existing mode).<section class="expertise-fit"> with <h2>Expertise-fit read</h2> — which instructional strategies are appropriate given the learner profile. Cite the expertise-reversal evidence so the read isn't opinion: [CogLoad-4] [T1] for novices; [CogLoad-19] [T1] for advanced; [Learner-16] [T1] for mixed./idstack:learning-objectives to develop ILOs grounded in this analysis. The objectives skill reads your task analysis and learner profile to recommend appropriate Bloom's levels and alignment strategies.Every finding in the HTML must correspond to a finding the manifest's needs_analysis section can carry, so downstream skills and bin/idstack-status can refer to them programmatically.
Create or update the project manifest. Use the Write tool to write .idstack/project.json.
CRITICAL — Manifest Integrity Rules:
updated timestamp must reflect the current time.needs_analysis.report_path to the value of $_REPORT_PATH from the bash block above — i.e., .idstack/exports/<course-slug>/needs-analysis.html.Write the manifest, then confirm to the user:
"Your needs analysis is saved. Two artifacts:
.idstack/exports/<course-slug>/needs-analysis.html — the branded HTML
report with evidence-backed findings, the training-justification read, and a
learner-profile expertise check. Open it in any browser. The folder is self-contained
(CSS is bundled), so you can zip or email it..idstack/project.json (the manifest — for downstream skills).Next step: Run /learning-objectives to develop learning objectives based on
this analysis. The objectives skill will read your task analysis and learner profile
to recommend appropriate Bloom's levels and alignment strategies."
The idstack manifest lives at .idstack/project.json. Schema version: 1.4.
This is the canonical schema. Every skill writes to its own section using the shapes documented here; all other sections must be preserved verbatim. There is one source of truth — this file. If the schema ever needs to change, edit templates/manifest-schema.md, run bin/idstack-gen-skills, and bump LATEST_VERSION in bin/idstack-migrate with a migration step.
Every skill that produces findings emits both:
bin/idstack-status), and.idstack/exports/<course-slug>/<skill>.html (the human view — read by the instructional designer).The HTML report follows the visual contract in templates/report.html.tmpl and the content contract in templates/report-format.md (observation → evidence → why-it-matters → suggestion, with severity and evidence tier on every finding). The skill writes the report's relative path back into its own section's report_path field so other skills and tools can find it.
<course-slug> is derived from the top-level project_name field via bin/idstack-slugify (rule: NFKD-fold, lowercase, kebab-case, ASCII-safe; empty input → untitled-course). The slug is computed deterministically — skills don't cache it in the manifest. All exports for a course — per-skill HTML reports, the pipeline dashboard at index.html, and LMS packages (course-export.imscc, scorm-export.zip) — live under the same .idstack/exports/<course-slug>/ folder so the deliverable is self-describing when zipped, emailed, or handed off.
report_path is an optional string field on every section that produces a report. It is a path relative to the project root (typically .idstack/exports/<course-slug>/<skill>.html). Empty string means the skill hasn't run yet, or ran in a mode that didn't produce a report. Renaming a course's project_name changes the slug, which moves future exports to a new folder; older folders are left in place.
1. Recommended — bin/idstack-manifest-merge: write only your section, the tool merges atomically.
# Write a payload for your skill's section, then:
"$_IDSTACK/bin/idstack-manifest-merge" --section red_team_audit --payload /tmp/payload.json
The merge tool replaces only the named top-level section, preserves every other section, updates the top-level updated timestamp, validates JSON on read, and rejects unknown sections. Use this in preference to inlining the full manifest in Edit operations.
2. Fallback — manual full-manifest write: if the merge tool is unavailable for some reason, Read the full manifest, modify only your section, Write back. Preserve all other sections verbatim. Use the full schema below as reference.
| Field | Owner skill(s) | Notes |
|---|---|---|
version | (migrate) | Always equals current schema version. Auto-managed by bin/idstack-migrate. |
project_name | (any) | Set on first manifest creation. Don't overwrite once set. |
created | (any, once) | ISO-8601 timestamp of first creation. Don't overwrite. |
updated | (any) | ISO-8601 of last write. Updated automatically by bin/idstack-manifest-merge. |
context | needs-analysis (initial) | Modality, timeline, class size, etc. Edited by skills that learn new context. |
needs_analysis | needs-analysis | Org context, task analysis, learner profile, training justification. |
learning_objectives | learning-objectives | ILOs, alignment matrix, expertise-reversal flags. |
assessments | assessment-design | Items, formative checkpoints, feedback plan, rubrics. |
course_content | course-builder | Generated modules, syllabus, content paths. |
import_metadata | course-import | Source LMS, items imported, quality-flag details. |
export_metadata | course-export | Export destination, items exported, readiness check. |
quality_review | course-quality-review | QM standards, CoI presence, alignment audit, cross-domain checks, scores. |
red_team_audit | red-team | Confidence score, dimensions, findings (with stable ids), top actions. |
accessibility_review | accessibility-review | WCAG / UDL scores, violations, recommendations, quick wins. |
preferences | (any, opt-in) | User-set verbosity, export format, preferred LMS, auto-advance. |
{
"version": "1.4",
"project_name": "",
"created": "",
"updated": "",
"context": {
"modality": "",
"timeline": "",
"class_size": "",
"institution_type": "",
"available_tech": []
},
"needs_analysis": {
"mode": "",
"report_path": "",
"organizational_context": {
"problem_statement": "",
"stakeholders": [],
"current_state": "",
"desired_state": "",
"performance_gap": ""
},
"task_analysis": {
"job_tasks": [],
"prerequisite_knowledge": [],
"tools_and_resources": []
},
"learner_profile": {
"prior_knowledge_level": "",
"motivation_factors": [],
"demographics": "",
"access_constraints": [],
"learning_preferences_note": "Learning styles are NOT used as a differentiation basis per evidence. Prior knowledge is the primary differentiator."
},
"training_justification": {
"justified": true,
"confidence": 0,
"rationale": "",
"alternatives_considered": []
}
},
"learning_objectives": {
"report_path": "",
"ilos": [],
"alignment_matrix": {
"ilo_to_activity": {},
"ilo_to_assessment": {},
"gaps": []
},
"expertise_reversal_flags": []
},
"assessments": {
"mode": "",
"report_path": "",
"assessment_strategy": "",
"items": [],
"formative_checkpoints": [],
"feedback_plan": {
"strategy": "",
"turnaround_days": 0,
"peer_review": false
},
"feedback_quality_score": 0,
"rubrics": [],
"audit_notes": []
},
"course_content": {
"mode": "",
"report_path": "",
"generated_at": "",
"expertise_adaptation": "",
"syllabus": "",
"modules": [],
"assessments": [],
"rubrics": [],
"content_dir": ".idstack/course-content/",
"generated_files": [],
"build_timestamp": "",
"placeholders_used": [],
"recommended_generation_targets": []
},
"import_metadata": {
"source": "",
"report_path": "",
"imported_at": "",
"source_lms": "",
"source_cartridge": "",
"source_size_bytes": 0,
"schema": "",
"items_imported": {
"modules": 0,
"objectives": 0,
"module_objectives": 0,
"assessments": 0,
"activities": 0,
"pages": 0,
"rubrics": 0,
"quizzes": 0,
"discussions": 0
},
"quality_flags": 0,
"quality_flag_details": []
},
"export_metadata": {
"report_path": "",
"exported_at": "",
"format": "",
"destination": "",
"items_exported": {
"modules": 0,
"pages": 0,
"assignments": 0,
"quizzes": 0,
"discussions": 0
},
"failed_items": [],
"notes": "",
"readiness_check": {
"quality_score": 0,
"quality_reviewed": false,
"red_team_critical": 0,
"red_team_reviewed": false,
"accessibility_critical": 0,
"accessibility_reviewed": false,
"verdict": ""
}
},
"quality_review": {
"report_path": "",
"last_reviewed": "",
"qm_standards": {
"course_overview": {"status": "", "findings": []},
"learning_objectives": {"status": "", "findings": []},
"assessment": {"status": "", "findings": []},
"instructional_materials": {"status": "", "findings": []},
"learning_activities": {"status": "", "findings": []},
"course_technology": {"status": "", "findings": []},
"learner_support": {"status": "", "findings": []},
"accessibility": {"status": "", "findings": []}
},
"coi_presence": {
"teaching_presence": {"score": 0, "findings": []},
"social_presence": {"score": 0, "findings": []},
"cognitive_presence": {"score": 0, "findings": []}
},
"alignment_audit": {"findings": []},
"cross_domain_checks": {
"cognitive_load": {"score": 0, "flags": []},
"multimedia_principles": {"score": 0, "flags": []},
"feedback_quality": {"score": 0, "flags": []},
"expertise_reversal": {"score": 0, "flags": []}
},
"overall_score": 0,
"score_breakdown": {
"qm_structural": 0,
"coi_presence": 0,
"constructive_alignment": 0,
"cross_domain_evidence": 0
},
"quick_wins": [],
"recommendations": [],
"review_history": []
},
"red_team_audit": {
"updated": "",
"confidence_score": 0,
"focus": "",
"report_path": "",
"findings_summary": {"critical": 0, "warning": 0, "info": 0},
"dimensions": {
"alignment": {"score": "", "findings": []},
"evidence": {"score": "", "mode": "", "findings": []},
"cognitive_load": {"score": "", "findings": []},
"personas": {"score": "", "findings": []},
"prerequisites": {"score": "", "findings": []}
},
"top_actions": [],
"limitations": [],
"fixes_applied": [],
"fixes_deferred": []
},
"accessibility_review": {
"updated": "",
"report_path": "",
"score": {"overall": 0, "wcag": 0, "udl": 0},
"wcag_violations": [],
"udl_recommendations": [],
"quick_wins": []
},
"preferences": {
"verbosity": "normal",
"export_format": "",
"preferred_lms": "",
"auto_advance_pipeline": false
}
}
These document the shape of array elements and dictionary values that the canonical schema leaves as [] or {}. Skills should produce items in these shapes; downstream skills can rely on them.
learning_objectives.alignment_matrix.ilo_to_activity — keyed by ILO id, values are arrays of activity names:
{ "ILO-1": ["Module 1 case study", "Discussion 2"], "ILO-2": [] }
learning_objectives.alignment_matrix.ilo_to_assessment — same shape, values are arrays of assessment titles.
learning_objectives.alignment_matrix.gaps[] — each item:
{
"ilo": "ILO-1",
"type": "untested|orphaned|underspecified|bloom_mismatch",
"description": "ILO-1 has no matching assessment in the active modules.",
"severity": "critical|warning|info"
}
learning_objectives.ilos[] — each item:
{
"id": "ILO-1",
"statement": "Analyze competitive forces in...",
"blooms_level": "analyze",
"blooms_confidence": "high|medium|low"
}
assessments.items[] — each item:
{
"id": "A-1",
"type": "quiz|discussion|rubric|peer_review|gate|...",
"title": "Module 1 Quiz",
"weight": 5,
"ilos_measured": ["ILO-1", "ILO-3"],
"rubric_present": true,
"elaborated_feedback": false,
"alignment_status": "weak|moderate|strong"
}
assessments.rubrics[] — each item:
{
"id": "rubric-1",
"title": "SM Project Rubric",
"criteria": [{"name": "...", "blooms_level": "...", "weight": 0}],
"applies_to": ["A-3"]
}
import_metadata.quality_flag_details[] — each item (replaces the legacy _import_quality_flags root field that sometimes appeared in the wild):
{
"key": "orphan_module_8",
"description": "Module 8 wiki content exists in the cartridge but is not referenced in <organizations>.",
"severity": "warning|critical|info",
"evidence": "Optional citation tag, e.g. [Alignment-1] [T5]"
}
red_team_audit.dimensions.<name>.findings[] — each item (matches the <dimension>-<n> id convention from the red-team orchestrator):
{
"id": "alignment-1",
"description": "ILO-2 (vision/mission) has no matching assessment.",
"module": "Module 4",
"severity": "critical|warning|info"
}
accessibility_review.wcag_violations[] — each item:
{
"id": "wcag-1",
"criterion": "1.3.1 Info and Relationships",
"level": "A|AA|AAA",
"description": "All cartridge HTML pages lack <h1> elements.",
"affected": ["page1.html", "page2.html"],
"severity": "critical|warning|info"
}
accessibility_review.udl_recommendations[] — each item:
{
"id": "udl-1",
"principle": "engagement|representation|action_expression",
"description": "Add transcripts to all videos.",
"status": "fully_met|partial|not_met"
}
quality_review.qm_standards.<standard>.findings[], quality_review.alignment_audit.findings[], quality_review.cross_domain_checks.<check>.flags[], and other findings arrays — each item:
{
"id": "<dimension>-<n>",
"description": "...",
"evidence": "[Domain-N] [TX]",
"severity": "critical|warning|info"
}
needs_analysis.mode, assessments.mode, and course_content.mode record which operating mode the corresponding skill ran in. Trigger: import_metadata.source ∈ {cartridge, scorm, canvas-api} plus the relevant section being non-empty (skill-specific check).
Allowed values per skill:
needs_analysis.mode: "design-new" or "audit-existing"assessments.mode: "Mode 1", "Mode 2", or "Mode 3" (Mode 1 = full upstream data, Mode 2 = ILOs-from-scratch, Mode 3 = audit existing assessments)course_content.mode: "build-new" or "gap-fill"Empty string means the skill hasn't run yet or didn't record the mode (legacy manifests).
assessments.audit_notes[] — only populated in Mode 3. Records which audit findings the user chose to act on:
{
"target_id": "A-3",
"action": "applied|deferred|declined",
"description": "Rubric criterion for ILO-2 added: 'Synthesis depth (1-4 scale)'.",
"reason": "Optional — only meaningful for deferred/declined."
}
course_content.recommended_generation_targets[] — populated in gap-fill mode. Lists artifacts upstream skills flagged as missing, with status:
{
"description": "Discussion rubric for Module 5",
"source": "red-team:alignment-3 | quality-review:learner_support-2 | user-request",
"status": "generated|deferred|declined",
"output_path": "Optional — set when status=generated, points to the generated file."
}
Have feedback or a feature request? Share it here — no GitHub account needed.
After the skill workflow completes successfully, log the session to the timeline:
"$_IDSTACK/bin/idstack-timeline-log" '{"skill":"needs-analysis","event":"completed"}'
Replace the JSON above with actual data from this session. Include skill-specific fields where available (scores, counts, flags). Log synchronously (no background &).
If you discover a non-obvious project-specific quirk during this session (LMS behavior, import format issue, course structure pattern), also log it as a learning:
"$_IDSTACK/bin/idstack-learnings-log" '{"skill":"needs-analysis","type":"operational","key":"SHORT_KEY","insight":"DESCRIPTION","confidence":8,"source":"observed"}'
npx claudepluginhub savvides/idstack --plugin idstackDevelops evidence-based learning objectives with Bloom's taxonomy classification and bidirectional alignment checking. Reads from /needs-analysis manifest to produce ILOs and alignment matrix.
Provides UI/UX resources: 50+ styles, color palettes, font pairings, guidelines, charts for web/mobile across React, Next.js, Vue, Svelte, Tailwind, React Native, Flutter. Aids planning, building, reviewing interfaces.