Building Your Own AI Skills

You've been using SmartChalk skills for a while now. You've pasted the Lesson Plan Architect into conversations. You've run the Weekly Teaching Reflection on Friday afternoons. You know how these skills work — the banner appears, it introduces itself, it asks a few questions, and it generates something useful.

Here's the thing most teachers don't realize: you can build your own.

A SmartChalk skill is not code. It's not programming. It's structured writing — a document that tells an AI how to behave for a specific task. If you've ever written a good lesson plan, you've done harder work than creating an AI skill. A lesson plan has objectives, procedures, assessment criteria, and differentiation strategies. A skill has a similar structure, just pointed at an AI instead of a classroom.

What a SmartChalk Skill Actually Is

Every SmartChalk skill is a single text document with four parts:

1. The Brand Banner This is the visual header the AI displays when the skill starts. It identifies the skill by name and tells both the AI and the teacher what's running. Think of it like the title slide of a presentation — it sets the context.

+------------------------------------------------------+
|  SmartChalk.AI                                       |
|  Socratic Seminar Prep . v1.0                        |
|  Instruction . High School . Universal               |
+------------------------------------------------------+

2. The Metadata Block This is a hidden block (wrapped in HTML comment tags) that contains machine-readable information about the skill: its name, category, grade levels, subjects, and which AI tools it works with. You don't need to understand HTML — it's a fill-in-the-blanks template. The AI reads it; humans don't need to see it.

3. The Protocol This is the behavioral contract — the six-phase sequence that every SmartChalk skill follows. It tells the AI to welcome the teacher, ask for inputs, offer a preview, generate the output, suggest refinements, and help with export. You don't write this section from scratch. It's standardized across all SmartChalk skills. You copy it from the template and make minor adjustments.

The six phases, in teacher-friendly terms:

Phase	What Happens	Teaching Analogy
Welcome	The skill introduces itself and explains what it does	The first day of class — you tell students what the course is about
Gather	It asks the teacher for the information it needs	Checking for prior knowledge before a lesson
Preview	It shows a sample output so the teacher knows what to expect	Modeling an assignment before students start
Generate	It creates the requested output	Guided practice — the skill does the work with narration
Refine	It offers adjustments based on what it just created	Feedback and revision — just like the writing process
Export Assist	It helps format the output for different uses	Choosing the right format — slides, handout, or document

4. The Skill Instructions This is the part that makes your skill unique. It's where you define:

• What role the AI plays (e.g., "You are an expert in Socratic questioning techniques")
• What inputs the teacher provides (e.g., "The text students will discuss, grade level, discussion goals")
• What the output looks like (e.g., "A set of tiered discussion questions organized by Bloom's taxonomy level")
• What makes the output good (quality standards)
• A sample "dry run" so teachers can see the output before using their own content

This section is where your teaching expertise lives. The protocol handles the AI's behavior. The Skill Instructions handle your domain knowledge.

Building a Skill: Walk-Through

Let's build one together. Meet Carla, a high school English teacher who runs Socratic Seminars regularly. She wants a skill that helps her prepare discussion questions — specifically, questions tiered by complexity so she can guide the conversation from surface-level to analytical.

Step 1: Name It and Describe It

Carla picks a name: Socratic Seminar Prep. She writes a one-sentence description: "Generate tiered discussion questions for Socratic Seminars, organized from comprehension to analysis to evaluation."

Step 2: Fill in the Banner and Metadata

She copies the banner template and fills in her skill name, category (Instruction), grade levels (High School), and compatibility (Universal — it works in any AI tool).

Step 3: Copy the Protocol

She copies the standard SmartChalk Protocol section. She makes two small adjustments to Phase 5 (Refine): instead of generic options, she adds specific refinement suggestions for discussion questions — adjusting Bloom's level distribution, adding text-dependent evidence requirements, or reframing questions for ELL accessibility.

Step 4: Write the Skill Instructions

This is where Carla's expertise matters. She writes:

Role: "You are a Socratic questioning specialist who designs discussion prompts that move student thinking from surface comprehension to deep analysis."

Required inputs: The text students will discuss, the grade level, and how long the seminar will last.

Optional inputs: Specific themes to explore, student reading levels, previous discussion topics in the unit.

Output format: Three tiers of questions:

• Tier 1 (Comprehension): 3-4 questions that confirm students read and understood the text
• Tier 2 (Analysis): 3-4 questions that ask students to interpret, compare, or connect ideas
• Tier 3 (Evaluation): 2-3 questions that ask students to judge, argue, or extend beyond the text

Each question includes a follow-up probe ("If students say X, push with Y").

Quality standards: Questions must reference specific passages or ideas from the text. No generic questions that could apply to any reading. Follow-up probes must anticipate common student responses.

Step 5: Write the Dry Run

Carla writes a sample: a Socratic Seminar on Chapter 3 of To Kill a Mockingbird, 10th grade, 45-minute discussion. She sketches out what the output should look like so the skill demonstrates its value before a teacher uses real content.

Step 6: Assemble and Test

She pastes the assembled skill into Claude and tests it. Does the banner display? Do the questions match her quality standards? Are the follow-up probes specific to the text? She adjusts the instructions until the output matches her expectations.

The SmartChalk Skill Builder

If building from a blank template feels daunting, SmartChalk's Build Your Own Skill does the heavy lifting. It's a meta-skill — a skill that builds skills. Tell it what task you want to automate, answer its questions about your requirements, and it assembles a complete skill in SmartChalk format. You can use the result immediately or submit it to the SmartChalk marketplace for other teachers to discover.

The skill builder walks through each section in order, asking questions like:

• "What teaching task does this skill automate?"
• "What information does the teacher need to provide?"
• "What should the output look like?"
• "What makes a good version versus a bad version of this output?"

Your answers become the Skill Instructions. The builder handles the banner, metadata, and protocol automatically.

What Makes a Skill Worth Building?

Not every task needs a skill. A good candidate for skill creation has three characteristics:

1. You do it repeatedly. Weekly, monthly, or each semester. One-off tasks aren't worth the investment.
2. It has a consistent structure. The output follows a pattern — tiered questions, formatted plans, structured feedback. Freeform creative tasks are harder to skill-ify.
3. Your expertise makes it better. Generic AI output isn't good enough. Your knowledge of pedagogy, your subject expertise, or your understanding of your students makes the skill's output distinctly better than a bare AI prompt.

Ideas from teachers who've built skills:

• Lab safety briefing generator (middle school science)
• Differentiated reading group assignments (elementary ELA)
• Parent conference talking points builder (any grade)
• Standards-based gradebook comment writer (high school)
• Morning meeting activity selector (elementary)
• Test review study guide creator (any subject)

From Personal Tool to Shared Resource

A skill you build for yourself might help other teachers. SmartChalk's marketplace lets you share skills with the community. When you submit a skill, it goes through a review process to check format compliance and quality. Accepted skills appear in the directory where other teachers can discover, use, and review them.

Building skills is one of the most concrete ways to contribute to the teaching profession. Your expertise doesn't have to stay in your room. A well-built skill packages your knowledge into something any teacher with any AI tool can use.

Your one action this week: Think of one task you do repeatedly that an AI could help with, and write the first three lines of a skill for it: the name, a one-sentence description, and the role the AI should play.