Teaching <Database Management> in the Age of AI Assistants
How Claude Code transforms course management from clicking through LMS menus to conversational collaboration—and why that matters for students learning to work alongside AI.
The Prompt That Started It All
“Create a subfolder for fall 2025 and get me enough information from my course for this semester for 554 from Canvas so that I can explore recreating the class to be run entirely inside Claude Code, and using GitHub as the source.”
That single sentence kicked off a 45-minute collaboration that fundamentally changed how I think about course management. Not because the task was revolutionary—extracting course data isn’t exactly cutting-edge—but because of how we did it.
I didn’t open Canvas. I didn’t click through menus. I didn’t export CSVs. I had a conversation.
Teachers as Builders: The Augmented Instructor
I’ve been writing about “teachers as builders” for a while now—the idea that educators aren’t just content deliverers but architects of learning experiences. We design, iterate, experiment, and construct. But here’s what I’ve come to realize: building is exhausting when your tools fight you.
Canvas is fine. It does what it’s supposed to do. But every time I want to answer a simple question—”Which students haven’t submitted their peer reviews?”—I’m clicking through three menus, waiting for pages to load, exporting data, opening Excel. The cognitive overhead isn’t in the question; it’s in the tooling.
What if the tool just... understood the question?
Enter the Canvas MCP Server
The Model Context Protocol (MCP) is Anthropic’s standard for connecting AI assistants to external data sources. I’d built a Canvas MCP server months ago, but today I used it to explore bringing the course out of canvas, to augment it on my computer with AI.
Here’s what happened when I asked Claude Code to fetch my BADM 554 course information:
mcp__canvas-api__list_courses()
mcp__canvas-api__get_course_content_overview(course_identifier="60366")
mcp__canvas-api__list_assignments(course_identifier="60366")
mcp__canvas-api__list_groups(course_identifier="60366")Within seconds, Claude had extracted:
43 assignments with IDs, points, and due dates
23 project teams with member lists
21 published Canvas pages
The complete 15-week course schedule
Discussion forums, office hours, everything
But here’s the key insight: I didn’t ask for any of this specifically. I said I wanted “enough information to explore recreating the class.” Claude interpreted that intent, determined what data would be useful, and fetched it systematically.
This is what I mean by augmented intelligence. I’m still driving—I set the direction, the goals, the pedagogical vision. But I’m not manually turning every wheel.
From Data Extraction to Knowledge Architecture
Raw data is useless without structure. What happened next is where the collaboration got interesting.
Claude didn’t just dump API responses into a file. It created a documentation architecture:
semesters/fall2025/
├── COURSE_INFO.md # Course overview, contacts, tech stack
├── DETAILED_SCHEDULE.md # 15-week breakdown with all links
├── ASSIGNMENTS_REFERENCE.md # All 43 assignments with Canvas IDs
└── CLAUDE_CODE_MIGRATION.md # Full migration plan for GitHub deliveryEach file was purposefully designed. COURSE_INFO.md contains everything a new TA would need on day one. ASSIGNMENTS_REFERENCE.md preserves Canvas IDs so future automations can reference them. The migration plan? That’s a strategic document outlining how to transform BADM 554 from Canvas-centric to GitHub-native.
I didn’t specify this structure. I said “document the course for Claude Code migration.” Claude proposed an architecture, and I refined it through conversation.
This is collaborative intelligence in action. The human provides intent; the AI proposes structure; the human validates and redirects; the AI executes and iterates.
The Template Repository Pattern
Halfway through our session, I realized we weren’t just documenting Fall 2025—we were building something reusable.
“Let’s move this folder into a separate folder under a new folder /teaching created at the same level as /code and /research. Name the folder badm554 to create a template course that I can then use every semester.”
One sentence. Claude understood the implications:
Create a new organizational structure (/teaching/)
Make BADM 554 semester-agnostic
Separate reusable content from semester-specific data
Initialize fresh git for the template
Now when Spring 2026 rolls around, I copy semesters/fall2025 to semesters/spring2026 and ask Claude to fetch the new Canvas data. The infrastructure is in place. The templates are ready. The cognitive load is near zero.
The CLAUDE.md: Teaching AI How to help students
Here’s where it gets meta.
Part of our session involved creating a CLAUDE.md file for the course repository—essentially teaching Claude Code how to behave as a teaching assistant for BADM 554:
## Your Role as Teaching Assistant
### DO:
- Help debug SQL queries and explain errors
- Explain database concepts (normalization, ER modeling, joins)
- Review ERD designs and suggest improvements
- Help interpret assignment requirements
### DON'T:
- Write complete solutions for graded assignments
- Give direct answers to quiz questions
- Complete lab exercises entirely for studentsThis is meta-pedagogy: I’m not just using AI to teach—I’m encoding pedagogical principles into the AI’s operational context. The CLAUDE.md file becomes a specification for educational guardrails.
When a student uses Claude Code in this repository, the AI knows it’s supposed to help them learn, not do their work. It knows to give hints instead of solutions, to explain concepts instead of generating answers.
The Cascade of Augmentation
Here’s the pedagogical vision that crystallized during this session:
Layer 1: AI augments the teacher. I use Claude Code to manage courses, extract data, generate documentation, analyze submissions. I’m still the architect of the learning experience, but I’m freed from mechanical overhead.
Layer 2: The augmented teacher teaches students to be augmented. My students aren’t just learning SQL and database design. They’re learning to work with AI tools. When they use Claude Code to debug queries or review their ERD designs, they’re developing a workflow they’ll use throughout their careers.
Layer 3: Students become AI-augmented professionals. The skills they learn aren’t just “database management.” They’re learning how to think alongside AI—how to provide intent, evaluate output, iterate on solutions, and maintain human judgment while leveraging machine capability.
This is what I mean by teaching in the age of AI assistants. The subject matter (databases) is almost secondary to the meta-skill: learning to be effective in an AI-augmented workflow.
What Actually Happened: A Timeline
9:00 AM - Initial request to fetch BADM 554 data from Canvas
9:02 AM - Discovered Canvas MCP server wasn’t connected to this session
9:05 AM - Created project-specific .mcp.json configuration
9:08 AM - Restarted Claude Code; Canvas MCP connected successfully
9:10 AM - First API calls: list_courses, get_course_details
9:15 AM - Comprehensive data extraction: assignments, pages, groups, schedule
9:25 AM - Documentation files created in Fall2025/ folder
9:30 AM - Migration plan drafted (CLAUDE_CODE_MIGRATION.md)
9:35 AM - Restructured to template repository pattern
9:40 AM - Created CLAUDE.md with teaching assistant guidelines
9:45 AM - Initialized fresh git, committed 33 files
Total time: 45 minutes. Manual equivalent: Several hours of clicking, copying, formatting.
Lessons for Teachers as Builders
1. Conversational interfaces change everything. The friction in course management isn’t the tasks—it’s the navigation. When you can state intent in natural language and get structured results, the entire workflow transforms.
2. AI augmentation compounds. When I’m augmented, I can design better learning experiences. When students are augmented, they learn more effectively. The gains multiply through the system.
3. CLAUDE.md is pedagogy-as-code. Encoding teaching principles into AI operational context is a new form of curriculum design. We’re not just writing syllabi; we’re programming educational AI behavior.
4. Templates beat repetition. Every semester shouldn’t start from scratch. Build once, template forever, customize per term.
5. The meta-skill matters most. Teaching students to work alongside AI may be more valuable than any specific subject matter. The databases are the vehicle; the AI-augmented workflow is the destination.
What’s Next
This session was exploratory—a proof of concept for what’s possible and to start ideating. Stay tuned for more experiments over winter break. The full vision could include:
Exploring Auto-graded SQL assignments via GitHub Actions
Peer review analysis through Canvas MCP
Student-facing CLAUDE.md that guides without giving answers
A hybrid of Canvas + Github + Claude Code - Perhaps better than taking all
Figuring out how to get students access to Claude Code - Perhaps this is the textbook expense replacement. Or perhaps use OpenCode as the backend with free models using a Claudish frontend
But more than features, what excites me is the paradigm shift. We’re moving from “using AI tools” to “teaching in an AI-native environment.” The classroom of the future isn’t a room at all—it’s a repository, a conversation, a collaboration between human teachers, AI assistants, and students learning to navigate both.
The cascade of augmentation starts with us.
This article was written by Claude (Opus 4.5) in collaboration with Vishal Sachdev, documenting a real development session on December 23, 2024. The Hybrid Builder chronicles AI-human collaboration in software development, education, and beyond.
Repository: github.com/vishalsachdev/badm554 (coming soon) Canvas MCP Server: github.com/vishalsachdev/canvas-mcp