Creating & Configuring Classes
Learn how to create new classes, configure learning environments, select competencies or curricula, and generate enrollment codes for your students. This guide covers both the UI workflow and programmatic creation via API.
Before You Start
- You must be logged in as an educator or administrator
- Your xAPI LRS connection must be configured
- You should have a Domain-Specific Competency (DSC) or Curriculum selected
- Optional: Prepare a scenario context if using SBCAT assessments
Understanding Class Components
Each UALS class consists of:
Basic Information
Title, description, subject, and grade level
Learning Framework
DSC with competencies OR curriculum with domains/concepts
Enrollment Code
Unique code for students to join the class
Configuration
ITS agent settings, scenario contexts, language preferences
Step-by-Step: Creating a Class via UI
Navigate to Teacher Dashboard
Go to /teacher-dashboard.html and ensure you're logged in.
You should see your existing classes (if any) and a "Create New Class" button.
Click "Create New Class"
This opens the Create Class modal. You'll see a form with several fields to fill out.
Fill in Basic Information
Provide the following required fields:
- Class Title: Descriptive name (e.g., "AP Computer Science A - Fall 2025")
- Description: Brief overview of the class goals and content
- Subject: Select from dropdown (e.g., "Computer Science", "Mathematics")
- Grade Level: Select appropriate level (e.g., "High School", "College")
Select Learning Framework
Choose one of two approaches:
Option A: Domain-Specific Competency (Recommended)
Select a DSC from the dropdown. Examples include:
- AI Literacy Competency (dsc-comp-ailc)
- Computational Thinking (dsc-comp-ct)
- Data Science Fundamentals (dsc-comp-ds)
- Programming Fundamentals (dsc-comp-prog)
Option B: Curriculum-Based
Select a curriculum structure with domains, subdomains, and concepts.
Configure Optional Settings
Customize the learning experience:
- Language: Default is English, supports multiple languages
- Scenario Context: For SBCAT, provide a narrative context (e.g., "You are a cybersecurity analyst...")
- ITS Agent Configuration: Select analysis level (1-10) for adaptive learning recommendations
You are a software engineer at TechCorp working on a mission-critical
e-commerce platform. Your team needs to implement new features while
maintaining high code quality, security, and performance standards.
Review and Submit
Click "Create Class" to submit. The system will:
- Generate a unique class ID (e.g.,
class-ailc-abc123) - Generate a unique enrollment code (e.g.,
ENROLL-XYZ789) - Create an xAPI statement with all class metadata
- Assign you as both Original Creator and Current Owner
- Initialize the class in the LRS database
Share Enrollment Code
After creation, you'll see the enrollment code in the class details. Share this code with students so they can join your class.
Creating Classes via API
Programmatic class creation is useful for bulk operations, integrations, and automated provisioning.
API Endpoint
POST /api/school/classes
Authorization: Bearer {token}
Content-Type: application/json
Request Body
{
"title": "AP Computer Science A - Fall 2025",
"description": "Advanced placement course covering Java programming, data structures, and algorithms.",
"subject": "Computer Science",
"gradeLevel": "High School",
"dscId": "dsc-comp-prog",
"language": "en",
"scenarioContext": "You are a software engineering intern at a tech startup...",
"itsAnalysisLevel": 3
}
Success Response
{
"success": true,
"class": {
"id": "class-prog-abc123",
"title": "AP Computer Science A - Fall 2025",
"description": "Advanced placement course...",
"subject": "Computer Science",
"gradeLevel": "High School",
"dscId": "dsc-comp-prog",
"enrollmentCode": "ENROLL-XYZ789",
"teacherEmail": "teacher@school.edu",
"teacherName": "Dr. Jane Smith",
"creatorEmail": "teacher@school.edu",
"creatorName": "Dr. Jane Smith",
"contentExperts": [],
"createdAt": "2025-11-23T10:30:00.000Z"
}
}
JavaScript Example
async function createClass(classData) {
const response = await fetch('/api/school/classes', {
method: 'POST',
credentials: 'include',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(classData)
});
if (!response.ok) {
throw new Error('Failed to create class');
}
const result = await response.json();
console.log('Class created:', result.class);
return result.class;
}
const newClass = await createClass({
title: "Introduction to AI Literacy",
description: "Learn fundamental AI concepts and ethical considerations",
subject: "Computer Science",
gradeLevel: "College",
dscId: "dsc-comp-ailc",
language: "en"
});
Advanced Configuration Options
ITS Analysis Levels
The ITS (Intelligent Tutoring System) provides 10 levels of adaptive learning analysis, from lightweight (Level 1) to comprehensive (Level 10). Higher levels use more agents and provide deeper insights, but take longer to process.
| Level | Name | Agents | Time | Best For |
|---|---|---|---|---|
| 1 | Lightning | 4 | 1-2s | Quick feedback, large classes |
| 2 | Quick | 11 | 2-4s | Recommended default |
| 3 | Standard | 20 | 4-8s | Balanced performance and depth |
| 4 | Enhanced | 35 | 8-15s | Advanced pedagogy |
| 5 | Professional | 50 | 12-18s | Multimodal intelligence |
| 10 | Complete | 100 | 25-40s | Research, individualized learning |
Scenario Contexts for SBCAT
Scenario-Based Computer Adaptive Testing (SBCAT) uses narrative contexts to make assessments more engaging and authentic. Effective scenarios:
- Provide a clear role for the student (e.g., "You are a data analyst...")
- Establish realistic constraints and goals
- Connect to real-world applications
- Maintain consistency across all assessment items
You are a policy advisor for a city government evaluating AI systems
for public services. Your role is to assess AI proposals for fairness,
transparency, and ethical compliance. You need to understand AI capabilities,
limitations, and societal impacts to make informed recommendations.
You are a data scientist at a healthcare analytics company analyzing
patient outcomes to improve treatment protocols. Your work requires statistical
rigor, ethical data handling, clear visualization, and actionable insights
for medical professionals.
Managing Enrollment Codes
How Enrollment Codes Work
Each class has a unique enrollment code generated automatically at creation. Students use this code to join your class without needing manual approval.
Format
ENROLL-ABC123
8-character alphanumeric after prefix
Uniqueness
Globally unique across all classes
Collision-resistant generation
Validity
Never expires
Reusable for multiple students
Sharing Enrollment Codes
Recommended methods for distributing codes to students:
- Learning Management System (LMS): Post in course announcements or syllabus
- Email: Send directly to enrolled students
- Printed Materials: Include in course handouts or syllabus
- Class Website: Display on password-protected class page
Regenerating Enrollment Codes
If a code is compromised or you want to restrict new enrollments, you can regenerate the enrollment code through the class details modal.
PATCH /api/school/class/{classId}
{
"enrollmentCode": "ENROLL-NEWCODE1"
}
Editing Class Details
What Can Be Modified
After creation, you can edit most class properties except the class ID:
UI Workflow
Open Class Details
Click on a class card in your dashboard to open the details modal.
Click "Edit" Button
Located at the top of the modal, this toggles edit mode.
Modify Fields
All editable fields become input boxes. Make your changes.
Save Changes
Click "Save" to persist changes via API. Changes are tracked in xAPI statements.
API Workflow
async function updateClass(classId, updates) {
const response = await fetch(`/api/school/class/${classId}`, {
method: 'PATCH',
credentials: 'include',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(updates)
});
const result = await response.json();
console.log('Class updated:', result.class);
return result.class;
}
await updateClass('class-ailc-abc123', {
title: "Advanced AI Literacy - Spring 2026",
itsAnalysisLevel: 4
});
Class Versioning & History
All class modifications are tracked in xAPI statements, creating a complete audit trail. This enables:
- Viewing who made changes and when
- Reverting to previous configurations if needed
- Compliance with educational record-keeping requirements
- Analytics on class evolution over time