Designing a Teacher's Work with AI

1. What I learned from asking AI to write code

When ChatGPT first appeared, I built programs by moving between a web chat and a code editor. I described the feature I wanted, copied the code AI supplied, and pasted any error messages back into the chat. I repeated the cycle of getting an answer, making changes, and running the program. With longer code, conditions I had explained earlier would disappear, or parts that had worked would change. I had to explain the previous work all over again.

Then tools such as Cursor changed how I worked. AI could read and edit project files directly, so I spent less time moving code between windows. If I asked for a screen where students solve problems and check answers, AI could locate relevant files, edit the code, inspect the run, and try another correction after an error.

Agentic coding goes beyond a one-time code suggestion: AI receives a goal and carries inspect → edit → run → observe → retry through multiple tool-using steps. Copying and pasting decreased, and work moved faster. But as AI handled more of the work directly, I learned that writing a good request was not enough.

The first difficulty was too much context accumulating in one conversation. An early requirement became mixed with a later decision. AI might revive a discarded plan or follow an error record unrelated to the current task. Just as a teacher gives a colleague the latest lesson plan and relevant materials, an agent needs the current goal, related files, confirmed decisions, and useful execution results. Designing what enters the task, when it is loaded, and what is recorded or excluded is context engineering.

Selecting relevant information did not solve everything. The contexts of different kinds of work still collided in one place. Reviewing a worksheet requires curriculum material, grade-level expectations, and accurate questions and explanations. Turning the same worksheet into an A4 print layout requires page dimensions, margins, typography, and print results. When one conversation moves back and forth between them, content criteria can disappear among CSS changes and print errors, or a layout correction can unexpectedly alter an already approved manuscript.

That experience showed that reducing context was not always enough: work with different purposes sometimes needed separate working contexts. A content-review agent could receive the curriculum and manuscript, while a print-layout agent received only the approved manuscript and output requirements. Each assignment needed a change boundary and output format, plus a defined handoff from approved content to layout. A multi-agent workflow separates two or more agent assignments and connects their results in this way. More agents are not automatically better; the approach helps when their contexts and ownership can be separated clearly.

Dividing the work exposed another difficulty. Describing ownership did not automatically restrict what an agent could do. Telling the layout agent “do not change the manuscript” did not remove its file-editing permission. If one assignment deleted a shared file or sent data externally, the other work could also be affected. The workflow therefore needed enforceable file boundaries, actions that required prior approval, a checkpoint before edits, a way to verify completion, and procedures for stopping or recovering after failure. Designing this environment of instructions, tools, permissions, records, verification, and recovery is harness engineering.

The three concepts form a chain of responses to concrete friction. When information becomes mixed, select the necessary context. When different contexts keep colliding, divide the work. When divided work can act on real files and commands, enforce boundaries and verification. Understanding this progression is enough for now. Each linked term provides fuller methods and related professional vocabulary.

Handing work to AI requires more than stating a goal. Supply the right context, decide what should be divided, and establish boundaries and checks.

Vibe coding is an informal term often used for expressing the intended result in natural language instead of writing every implementation detail yourself. This course uses that approachable starting point, but it does not stop at “make this” and accept whatever appears. We will explain a teacher's real task, inspect what AI actually changed, and judge whether the result fits both the instructional purpose and the safety requirements.

2. Teachers already make what they need

Teachers already make many of their own materials. We adapt commercial worksheets to our classes, change the criteria in assessment rubrics, and combine resources into new classroom activities. Even when finished materials exist, adjusting them for our own lessons is a natural part of the job.

We can think about tools in the same way. A service's input form may not match our workflow, or it may lack one essential feature. If we have to download its output and reorganize it anyway, a small tool that produces a draft in the format we need may be more convenient.

Rather than fitting our lessons and work to a service, we make the tools we need. This course is about DIY for teachers.

DIY means making or adapting something yourself to meet a need. AI can help teachers turn their practical knowledge into working procedures and programs. The teacher who does the work knows best which information is needed, what must be checked, and what would make the result genuinely useful.

Many web services now advertise AI features such as document summaries, question generation, and notice writing. Some can be implemented by adding task-specific instructions and an interface to an existing large language model (LLM). An LLM can read and summarize text or generate new sentences. An API is a defined interface through which programs exchange requests and responses. A model provider's API lets your program send a request to its model and receive a response.

For example, a notice-drafting tool can collect an event's purpose, schedule, and required materials, send them to a model with writing instructions, and display the response in a set format. A small feature like this may be reasonable to build yourself. However, placing an API key in browser or student-facing code exposes the secret. A real service needs a trusted server or managed proxy plus authentication, rate and budget limits, and appropriate logging and retention controls.

Operators of API-based services also pay for model usage, so subscriptions may limit generations or credits. API usage is often billed separately from a consumer chat subscription, though providers may offer free allowances or trial credits. Check the provider's account and pricing terms directly.

A tool you build can match your input fields, writing criteria, and output format, and light usage may cost less than several subscriptions. Heavy usage may cost more, and you take responsibility for protecting keys, monitoring usage, and checking data-handling terms. Compare maintenance responsibility as well as price.

Building an entire service with search, integrations, security, and collaboration is a substantial undertaking. Start with one small feature you use often. The value of DIY is building only what your work needs, then trying it yourself and improving it.

3. Turn verified procedures into skills, and repeated user functions into apps

When we think about making our own tools, an app screen often comes to mind first. For a teacher's individual work, though, defining how AI should work can sometimes be more useful. The materials and requirements change from task to task, and we often need to adjust direction after seeing a result.

Consider making a worksheet. The length of the explanation, difficulty of the questions, and type of activity vary with the unit and the students' level. After seeing the first draft, you add judgments such as, "This question uses a concept students have not learned yet," or "Replace one calculation question with a question asking students to explain their reasoning." This kind of work suits an ongoing conversation with AI.

Explaining the same criteria from scratch every time is tedious. First complete and review a real worksheet. Then bundle the procedure, reference materials, output format, and checking criteria that worked. In this course, an AI skill means a reusable folder that organizes this bundle so an AI tool can load it again. Under the Agent Skills specification, a SKILL.md file contains the name, description, and instructions, alongside any necessary code and reference materials. We will cover the file structure in the skill-building exercises.

A worksheet-creation skill might include these instructions:

• First confirm the grade level, unit, learning objectives, and lesson duration.
• Refer to the curriculum materials and worksheet template supplied by the teacher.
• Draft a concept explanation, an exploratory activity, and comprehension-check questions, in that order.
• Check the questions and explanations, and flag anything that lacks sufficient support or needs the teacher's judgment.

With this preparation, you can provide materials for a new unit and start with the same procedure. Continue the conversation to make adjustments for the particular lesson. As your experience and criteria develop, the skill improves too. The exact way you register and load a skill depends on the AI tool you use.

An app is executable software that provides a function to a person or another system. Consider one when other people need a consistent way to provide input and use a feature, or when you want to repeat the same function through a button or command. Screens and storage are common app features, but they are not requirements.

My first classroom trial of AirClassSlide (in Korean) was a case that needed a user interface. Students kept asking, “Could you show the prompt again?”, “Where is the file?”, and “How do we submit our work?” Instructions were on the teacher's screen, files were elsewhere, and submissions went by email. I built a way for students to view prompts and files on their own screens and submit work within the same lesson flow.

If you want AI to reuse a working procedure, consider a skill. If you want to provide people with a defined function, consider an app. They are not mutually exclusive stages, and storage alone does not distinguish them. You may finish one worksheet and stop, or use a skill to draft questions and an app to deliver them to students.

Following the path from worksheet creation to student learning makes the roles of skills and apps clearer.

Figure 1. The teacher works flexibly with AI to create materials, while students use the prepared app's screens and procedures. Teacher review stands between the AI draft and the materials students receive.

4. From roles, materials, and goals to safe working requirements

Skills and apps start in the same place: describe your work concretely enough for AI to act on it. This course begins with roles, materials, and goals, then adds scope, prohibitions, completion criteria, verification methods, and actions that require approval before real work begins.

Element	Question to answer	Worksheet example
Role	What work will AI help with?	Assist by drafting a worksheet based on the teacher's materials
Materials	What should AI refer to?	Curriculum excerpts, an existing worksheet template, fictional examples, and file locations
Goal	What result counts as success?	Produce activities, comprehension-check questions, and explanations in the required format, aligned with one lesson's learning objectives

We begin by writing these elements in a project-root AGENTS.md. It is this project's top-level brief for roles, materials, goals, and working constraints. Later plans and design documents follow its requirements. OpenCode reads this file as instructions, though other tools have different conventions. In the workshop, ask AI to explain the requirements it applied and verify them yourself.

With that basis in place, identify missing materials, the first small deliverable, files AI may change, completion criteria, and verification methods. Require approval before deletion, external transmission, deployment, payment, or other high-impact actions. If a decision is ambiguous, AI should ask rather than decide on its own. Review the plan before work begins.

When you receive a finished file, open it yourself. If it is an app, run it and enter some values. If the result is wrong, describe the materials used, the expected result, and the actual result when asking for a correction. Revise the instructions and plan as you repeat this process. This is an agentic way of working: AI carries out file changes and execution, while the human checks the requirements and results.

The diagram shows the flow. Rather than trying to finish everything at once, repeat small cycles of action and checking.

Figure 2. Even when AI handles execution, the teacher sets the requirements and judges the result. When the goal changes, update the working guide too.

The missing context and unintended changes described earlier make scope and recovery important. Keep a checkpoint in a separate working folder or Git commit, and inspect the tool's actual permission and approval settings. Git can recover recorded file changes; it cannot undo data already transmitted, API calls, database changes, or deletion of untracked files. Keep secrets out of Git and approve external side effects before execution. Use only fictional data in the exercises. Before entering or uploading any real student data to an AI service, first obtain required school authorization and check applicable privacy requirements. Pseudonymized data remains personal data when a person can be re-identified. Even when use is authorized, minimize the data and check the service's retention period, training use, deletion procedure, and access controls. Compare AI-generated answers and citations with the source material.

5. Where this course begins

Our workspace centers on VS Code. VS Code is the workshop for editing files, running programs, and inspecting results; OpenCode is the AI coding tool connected to work with those files and commands. Cursor was an earlier example of a similar workflow, while OpenCode is the tool used in this course.

After learning the workspace in Part 2, the course has three activities.

1. Activity 1: Create a Skill (Parts 3–6). Read an existing worksheet, write and review a new one, and print it. Save the verified procedure as a skill to reuse with other materials.
2. Activity 2: Web Automation (Part 7 onward). Connect AI to Chrome, find official documents, and receive notifications about new pending approvals.
3. Activity 3: Build an App (to be added later). This follows the web automation activity.

Not every task needs to become a skill or an app. Real examples from this blog and learning projects will help us decide which extensions are useful.

You do not need to decide every feature at the start. Think of one teaching or administrative task you have repeated recently, and complete these three sentences. Do not include real students' personal information.

• What I want to do: I want to reduce or improve the work of __________.
• Materials to refer to: For this task, I use __________.
• The result I want: __________ will use the result, and it will count as a success if they can __________.

For example: "I want to spend less time drafting worksheets for each unit. I will refer to curriculum materials and an existing worksheet template. It will be a success if I can review the draft and adapt it for my lesson."

These three sentences are the starting point for your first task. Just as you adapt worksheets to your class, you can shape the way AI works and the tools it uses to fit your own lessons and work.

In the next post, we will create the folder and instruction file for the first worksheet task.

References

• Anthropic: Effective context engineering for AI agents — Selecting context, compacting conversations, recording decisions, and structuring subagents
• Anthropic: How we built our multi-agent research system — A research-system case study covering the benefits of delegation and the costs of token usage and coordination
• OpenAI: Prompt caching — Reusing repeated input and reducing its cost
• OpenAI: Harness engineering — Designing the working environment, documentation, and feedback mechanisms for agents
• Agent Skills specification — Organizing skill instructions, code, and reference materials