@weihaoqu/curriculum-designer-skill 1.0.0

package/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: curriculum-designer
+description: Helps teachers and instructional designers create a structured curriculum or teaching plan from a list of topics or a specification document. Use when the user wants to design course materials, lesson plans, or a syllabus.
+---
+
+# Curriculum Designer
+
+This skill guides the process of creating a structured teaching plan or curriculum from a source document outlining course topics or projects.
+
+## Workflow
+
+The process is iterative, tackling one module or topic at a time to ensure clarity and gather focused feedback.
+
+### 1. Identify Source Material & Goal
+
+- **Confirm Goal:** First, confirm with the user that their goal is to create teaching materials, a lesson plan, or a curriculum.
+- **Identify Source:** Ask the user to point to the source material that contains the list of topics (e.g., a project specification markdown file, a list of chapters, etc.). If no source exists, ask the user to provide the list of topics to be covered.
+- **Establish Output File:** Agree on a filename for the final teaching plan (e.g., `teaching-plan.md`).
+
+### 2. The Core Loop (For Each Topic)
+
+For each topic/module identified in the source material, follow this structured interview process:
+
+#### a. Propose Prerequisites
+
+- Analyze the topic and propose a numbered list of 3-5 potential **prerequisites**. These are the foundational concepts a student should know *before* starting the module.
+- Ask the user to select the relevant prerequisite numbers.
+
+**Example Prompt:**
+> **Topic: Static Taint Analysis**
+> Please choose the foundational knowledge students should have:
+> 1.  Basic API Concepts
+> 2.  Graph Theory Fundamentals
+> 3.  Data-Flow Analysis Concepts
+> 4.  Security Best Practices
+
+#### b. Propose Core Concepts
+
+- Propose a numbered list of 4-6 **core concepts** that should be taught within the module.
+- Ask the user to select the relevant concept numbers and indicate any that should be emphasized.
+
+**Example Prompt:**
+> Please select the core theoretical ideas to be taught:
+> 1.  Modeling Privacy Policies as Code
+> 2.  Graph Reachability Analysis
+> 3.  Relational Reasoning
+> 4.  Static API Call Analysis
+
+#### c. Propose a Teaching Order
+
+- Based on the user's selections, use your reasoning to synthesize a logical **teaching order**.
+- Structure the output as a series of 4-6 "Lessons."
+- For each lesson, include an "Objective" and the "Content" to be covered.
+- **Consult `references/pedagogy.md`** for common teaching patterns (e.g., "Problem-First," "Theory-to-Practice") to create a more effective and logical flow.
+
+#### d. User Approval & Refinement
+
+- Present the proposed teaching order to the user and ask for their approval. Be prepared to make adjustments based on their feedback.
+
+### 3. Generate the Artifact
+
+- Once the user approves the lesson plan for a module, append the well-formatted Markdown for that module to the designated output file.
+- Use clear headings and lists to ensure the final document is readable and well-structured.
+
+### 4. Continue to Next Topic
+
+- After saving the progress, move to the next topic in the source material and repeat the core loop.
+- Once all topics are covered, inform the user that the teaching plan is complete.

package/index.js

@@ -0,0 +1,2 @@
+// This file is intentionally left blank.
+// It serves as the main entry point for the npm package.

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@weihaoqu/curriculum-designer-skill",
+  "version": "1.0.0",
+  "description": "Helps teachers and instructional designers create a structured curriculum or teaching plan from a list of topics or a specification document. Use when the user wants to design course materials, lesson plans, or a syllabus.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "SKILL.md",
+    "references/"
+  ],
+  "keywords": [
+    "gemini-skill",
+    "gemini-cli",
+    "curriculum",
+    "teaching",
+    "education",
+    "lesson-plan",
+    "instructional-design",
+    "ai-agent"
+  ],
+  "author": "Weihao Qu",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weihaoqu/cs336-course-design.git",
+    "directory": "curriculum-designer"
+  }
+}

package/references/pedagogy.md

@@ -0,0 +1,41 @@
+# Pedagogical Patterns for Curriculum Design
+
+This document outlines common pedagogical (teaching) patterns. When designing a lesson plan, refer to these patterns to structure the material in a logical and effective way.
+
+---
+
+### 1. Problem-First (Concrete-to-Abstract)
+
+- **Description:** Start with a concrete, relatable, and motivating problem. Let the student grapple with the "why" before introducing the "how." Once the problem is well understood, introduce the abstract theory or tools needed to solve it.
+- **When to Use:** Excellent for introducing a new, complex topic. It immediately establishes relevance and provides a clear goal for the student.
+- **Example Flow:**
+    1.  Show a piece of code with a subtle security bug (e.g., a Use-After-Free).
+    2.  Manually trace how an attacker could exploit it.
+    3.  Ask: "How could we find this bug automatically?"
+    4.  Introduce the theory of Path-Sensitive Analysis as the solution.
+
+### 2. Theory-to-Practice (Abstract-to-Concrete)
+
+- **Description:** Start by introducing the formal theory, definitions, and framework. Build the intellectual toolkit first, then apply that toolkit to a practical example.
+- **When to Use:** Useful when the practical examples are too complex to understand without knowing the terminology and rules first. Good for more mathematically-inclined topics.
+- **Example Flow:**
+    1.  Define a Security Lattice and the rules of information flow (`L ⊑ H`).
+    2.  Define the formal typing rules for a security type system.
+    3.  *Then*, show a piece of code and use the rules to type-check it and find a violation.
+
+### 3. Scaffolding / Simple-to-Complex
+
+- **Description:** Introduce a concept in its simplest possible form. Once the student grasps the basic idea, progressively add layers of complexity, features, or edge cases.
+- **When to Use:** Almost always a good idea. It's the core of good teaching. It avoids overwhelming the student and builds a strong foundation at each step.
+- **Example Flow:**
+    1.  **Lesson 1:** Introduce a "Taint Lite" model that only handles direct assignments.
+    2.  **Lesson 2:** Add complexity by handling simple expressions (`y = x + z`).
+    3.  **Lesson 3:** Add complexity by considering control flow merges (`if/else`).
+    4.  **Lesson 4:** Add complexity by considering function calls (interprocedural analysis).
+
+### 4. Recap and Refresh
+
+- **Description:** Begin a new module or complex lesson by briefly reviewing the essential concepts from previous lessons that are prerequisites for the current topic.
+- **When to Use:** At the start of every new module that builds on previous ones.
+- **Example Flow:**
+    - "In our last module, we discussed Control-Flow Graphs. Today, we'll use that knowledge to build a Control-Flow Integrity checker. As a reminder, a CFG consists of..."