The Distinction That Matters
There is a distinction between two kinds of work that matters more than any other distinction in a design education right now. It is not the distinction between AI-assisted and unassisted. It is the distinction between work that develops the student as a thinker and work that merely produces output.
When AI is used, something is always happening. The question is what is happening to the person who used it.
If AI formats references, structures a bibliography, or converts notes into a presentation, the student is saving time and their thinking remains theirs. If AI is telling the student what their project is about, why it matters, or what position they hold, something else is happening. The output arrives, but the student has not moved. They are in the same place they were before they asked, except now they have language that sounds like theirs but is not. They have an answer they did not earn. The worst part: they may not notice the difference.
The position exists to name what to notice — and to give the structure that makes it noticeable.
The Boundary: What, Why, How
Every piece of work — a concept statement, a research question, a design proposal, a thesis argument — involves three layers. Each layer answers a different question, and each layer has a different owner.
The boundary is strict — not because AI cannot generate plausible answers above the line, but because that is precisely where your thinking needs to develop.
The boundary is strict. Not because AI cannot generate plausible answers to what and why — it can, and that is precisely the danger. The boundary is strict because what and why are where thinking develops. Outsource them, and the student arrives at the end of their education with a portfolio full of work they cannot explain, defend, or build upon.
What AI Must Not Do
AI must not define the problem. The concept is the student's to struggle with; the struggle is not inefficiency, it is the curriculum.
AI must not tell the student why something matters. The model can generate a rationale that sounds convincing, citing trends and frameworks, but it will not know why this student cares. If the student cannot articulate why they care, no amount of generated language will substitute for the absence — worse, the language will mask the absence from them.
AI must not make the judgements. "Is this coherent?" "Is this question worth pursuing?" "Is this direction stronger than that one?" These are judgements. They require a position — a sense of what is valued, what is compelling, what is missing in the world. A model does not have positions. It has probability distributions over what text tends to follow what text; its "opinions" are statistical artefacts, not convictions.
AI must not construct the argument. The argument is the skeleton of the intellectual work. A borrowed skeleton does not bend where the student's body does.
The line, expressed plainly: AI must not write the concept note. A concept note is not a how document — it is the place where the student articulates what they are making and why it matters. If AI writes it, the student's thinking did not become visible — AI's thinking did, wearing the student's name. The document passes inspection but fails the only test that matters: can the student defend every sentence in it as a position they actually hold?
What AI can legitimately do is large and worth taking seriously: write code, plan a project, plan a study, find and organise sources, structure a draft, clean up language, handle the mechanical work of citation, formatting, transcription, data visualisation. These are how tasks. The thinking is already done; AI helps with arrangement.
The Loop: Doing Changes Knowing
The boundary is real and it matters. But read too literally, it suggests that what and why arrive first, fully formed, like decisions made at a desk, and how follows as execution. The student decides what the project is, decides why it matters, then builds it. That is not how practice works.
In practice, the relationship runs both ways. The student begins with a tentative what and a vague why. They start doing — the how. The doing changes what they understand about what they are making and why it matters. The first prototype reveals that the project is not about what they thought. The first draft reveals that they care about a different question than the one they wrote down. The first user test reveals that the problem they were solving was not the problem that needed solving.
This is not failure. This is how understanding works. The doing is not downstream of the thinking. The doing is thinking — in a form that cannot be accessed any other way.
A designer with ten years of experience does not have a better what and why because they are smarter. They have been around the loop thousands of times.
Each pass through the loop, the what becomes more precise — not because the student thought harder, but because they made something and the thing they made told them something about what they were actually trying to make. Each pass through the loop, the why becomes more honest — not because they reflected more, but because the gap between what they said mattered and what they actually spent energy on became visible in the work itself.
Staying in the Loop With AI
The boundary says AI can handle how. The loop adds a complication: if AI handles all of the how, the feedback is lost. The doing is where the learning happens. If the student never makes the wireframe themselves, they never discover that the layout they imagined does not work — and they never ask the question that discovery would have triggered. If AI generates all the research summaries, the student never encounters the sentence in a paper that stops them, the one that contradicts their assumption and forces them to revise what they thought the project was about.
The loop requires that the student is in the doing, not just receiving its outputs. There is a difference between asking AI to "write the code for this interaction" and then reading, testing, and modifying it — and asking AI to "build this feature" and accepting whatever arrives. In the first case, the student is in the loop. In the second, they have stepped outside it.
The Two Tests
Before using AI for any part of the work — and again, after — two tests.
The Tests
The first test runs before. If yes — AI helped with the how; the thinking is intact. If no — AI replaced the thinking. There is output but no understanding, and the distance will become visible the moment someone asks a question that was not anticipated.
The second test runs after. If yes — the loop is working; the how is feeding the what and the why; the student is developing. If no — either the task was purely mechanical, which is fine, or the student was too far from the doing for the learning to reach them. Engaging with AI's output means reading it, questioning it, modifying it, arguing with it. Accepting means pasting it in and moving on. The first keeps the student in the loop. The second removes them from it.
Why This Is Hard
The framework would be simple if AI produced obviously bad answers to what and why questions. It does not. It produces fluent, structured, plausible answers. It sounds like a thoughtful peer who has read widely and thinks clearly. This is what makes it dangerous for learning — not because it is wrong, but because it is adequate. Adequate enough that the student does not notice they have stopped thinking.
The pattern works like this. The student faces uncertainty — what is my project about, why does it matter? Uncertainty is uncomfortable. AI resolves it instantly. The student feels relief. They proceed with confidence they did not earn. The gap between their confidence and their understanding widens. The gap becomes visible under pressure — juries, critiques, interviews, real projects.
The comfort of the resolved uncertainty is real. So is the cost. The student arrives at the end of a semester, or a degree, with work that is polished on the surface and hollow underneath — not because they are lazy or dishonest, but because they never had to sit with the discomfort long enough for their own thinking to emerge.
The discomfort is the curriculum. Not all of it, but more of it than the student might want to believe.
The Deal: Higher Ceiling, Higher Standard
This framework is not a restriction on AI use. It is a redirection.
When AI handles the how — the code, the project plan, the study design, the formatting, the source-finding — it raises the ceiling on what can be executed. Tasks that would have taken weeks take days. Technical barriers that would have stopped the student become manageable. The means available expand dramatically.
This is not a small thing. It changes what can be demanded of the student. If AI helps build a working prototype in a week instead of a month, the student should be building more ambitious prototypes. If AI helps plan a study with methodological rigour they could not have achieved alone, they should be asking harder research questions. The excuse that "I couldn't build it" no longer holds.
The Deal
A student without AI who submits a simple static poster because they could not code an interactive version — that is a reasonable constraint. A student with AI who submits the same static poster has no such excuse. The tools have changed; the expectation of what is demonstrated must change with them. Concept notes, research questions, design proposals should be more ambitious than they would have been without AI, not less. The saved time and expanded capability are not a holiday. They are capacity that should be reinvested into the depth and ambition of the thinking.
The Koher Principle
This framework is the pedagogical translation of a principle developed in the context of building AI tools.
The tool-side principle: AI handles language. Code handles judgement. Humans make decisions. That is Split-Domain Cognition — the architectural law that Koher's production tools enforce, described in the architecture specification. For learners, the translation is: AI handles language. The discipline handles structure. The student handles meaning. The how layer, where AI is legitimate, is the language layer — generating, organising, formatting, finding. The what and why layers, where AI must not operate, are where judgement, position, and commitment live. These are not efficiencies to be optimised. They are capacities to be developed.
A tool that reveals the shape of the student's thinking is useful. A tool that replaces the act of shaping the thinking is not. The difference is not always obvious from the outside. But the student will know — if they are honest with themselves — which one is happening.
The Boundary and the Loop is the framework underneath several Koher positions and is the practical interface students meet first. The Envelope of the Prompt names why a prompt cannot do what code can; this position names why a student cannot let AI do what their thinking must. Learning by Negotiation describes what it looks like to stay in the loop with a more capable partner; this position is the law the negotiation enacts. The Koher declaration of AI co-authorship names the same division of labour at the level of the practitioner — Prayas does judgement, Claude Code does synthesis. The architecture is autobiography, and the framework is the architecture rendered as pedagogy.
A Note on Honesty
The framework does not ask for the avoidance of AI. It asks for honesty about what AI is being used for.
Using AI to generate a concept statement and then presenting it as one's own thinking is not primarily an academic integrity problem, though it is that too. It is a self-knowledge problem. The student is lying to themselves about what they understand. The jury will not catch them. The interview might. But the real cost is quieter: they will not know what they think, because they never had to find out.
The students who develop most are not the ones who avoid AI or the ones who use it most cleverly. They are the ones who know, at every point, what is theirs and what is not.
Related: Learning by Negotiation — what it looks like to enact this framework with a more capable AI partner inside a classroom.