Kuyun AI · Works to try

Help · Practice in a course

Practice in a course

A course's practice sets: what counts as the same answer, saying you are right, a finished sheet, a set sat whole as a paper, and writing code with your study partner beside it. Reading, a reminder to study and a briefing's daily rhythm are Studying with a project; the overview is Projects.

Practice activities

A course's practice is not typed into the chat one line at a time. The person writing the course files each practice set — a drill of blanks, a multiple-choice quiz, listen-and-repeat, dictation, or flashcards — as a set of items — or, in a programming course, a small program to write — and the chapter shows it as a card with a Start button, in the chapter and in the study conversation when the assistant brings it up — until the course is archived, after which the chapter still reads and the Start button is gone (see "Ending one" in Renaming, copying, archiving and deleting a project). Starting one opens a panel that walks you through the items: it checks each answer and shows the right one when you miss. In a course that teaches a language, it also plays the sentence so you can hear it and, where the course asks for it, listens while you say it back and tells you whether it heard the same words — saying it back is practice, not a test: after two tries you can skip on. A course on any other subject never asks you to say its sentences aloud. Your place is kept, so you can stop and continue later on any device. A set can also be a whole paper, sat the way a test is — see "A paper" below.

What counts as the same answer. Capital letters, punctuation and extra spaces never count against you, and in English do not and don't are one answer. A dictation is right when you type the sentence you heard. Each language adds what is its own:

Your study partner goes by the same rule when it judges an answer in the conversation.

If you think you are right. When a typed answer is marked wrong — a fill-in or a dictation — press I think I'm right. That item then counts neither as right nor as missed: your sheet marks it ?, and your study partner knows you said it was right. Your answer goes to the people who made the course, without your name, so they can tell whether the check was wrong; if they agree, they add it, and it is right for everyone from then on. Nobody tells you either way. In a course shared with only you, they can tell the answer is yours. You can also say it to your study partner, which can send them a note (see "Telling the people who made it" in Studying with a project).

Japanese courses made before 9 November 2026 were written with each answer one way. Kuyun goes back over them and adds the other writing beside each answer, so both are right. If you made such a course, a fill-in question on the lesson's page shows the added answer after yours: たべます / 食べます. For a dictation or a listen-and-repeat sentence the other writing is accepted without being shown there. None of the answers or sentences you wrote is changed, yours stays the answer a learner is shown, and an answer Kuyun was not sure of is left as it was. A course you have archived is left alone.

When a set is done, the panel shows the whole sheet — every item, what you answered, and on a miss the right answer and the course's note — and send result posts that sheet into your study conversation, so it stays there to come back to, on any device, and your study partner sees exactly where you went wrong rather than a score alone. A long set keeps the misses in view and folds the rest under one line. The practice card in the chapter keeps a review link to your last sheet as well. What you answered is kept with the course, for you and your study partner; the people who made the course see none of your answers or results, except an answer you sent with I think I'm right, and never your name.

A paper. A course can file a set as a whole paper — a mock exam, a reading test, a chapter exam — and it is sat the way a test is. Every question is open from the start: answer in any order and change an answer as often as you like. Where a part's questions are about a text, the text stays beside them. A phone shows one of the two at a time, with Text and Questions to switch between them, and each keeps its place while you look at the other. A paper in several parts has a tab for each, with how many of its questions you have answered. Nothing is checked while you work. You press Hand in when you are done — it asks once if questions are still unanswered — and only then see the marked paper: every question, what you answered, the right answer and the course's note on a miss, and your score.

A paper may have a clock. It then opens on a cover that says how many questions and how many minutes, and the clock starts when you press Start. It does not stop: leaving the page or putting the phone away hands no time back, and when it runs out the paper is handed in as it stands. The time you used is kept with the result.

A part of a paper may be heard instead of read — a listening test. Its recording has a player above the part's questions. Where the paper's author made it a test, the recording plays once: you press Play the recording and it runs to its end, with no pause and no going back, and it keeps playing while you look at another part. If it stops anyway — the connection drops, you leave the page — Play on carries on from where you heard it, on the same browser; a recording that has finished does not play again while you sit the paper. Other recordings play as often as you like, at your listening speed. Only one plays at a time. Once you hand in, every recording plays freely, and where the author filed what the recording says, those words appear beside your marked answers. A recording is a sound file the course's author put in the course; Kuyun does not make it.

A paper may also say what a score reads as — "32 of 40 · Band 7" — from a table its author filed with it. That reading is the author's own estimate for practice on that one paper. It is not a result from any examining body, Kuyun adds nothing to it, and a past result keeps the reading it had even if the author changes the table later.

A paper may ask for a written answer — a letter, an essay, a report. It is a large box with a count of your words under it and how many the task asks for; nothing helps with spelling, as in a test. A written answer has no right answer to be checked against, so it is in no score: a paper with other questions gives its score for those, and a paper of written answers alone is simply handed in.

Once you have handed in, each written answer has a Have it marked button. Pressing it sends that one answer — the answer you handed in, as it was — to a language model, which marks it against the guide the paper's author filed: for each thing the guide looks at, the level your answer is closest to, why, the passages of your own writing that show it, and one thing to practise first. What the answers read as together is given as a range — "Band 6–7", never one figure — and only once every written answer on the paper is marked. Know what this is:

Your written answers and their marks are kept with your results in the course, as yours: the people who made the course see neither, and send result tells your study conversation only that you wrote and how many words — your study partner is not shown the text unless you paste it into the conversation yourself. On a work that has been archived you can still read the marks you have; no more can be asked for.

Until you hand in, the answers you are writing are kept in the browser you are using: you can leave the page and come back to them there, but they are not on your other devices, and signing out forgets them. Once handed in, the result is kept with the course like any other set's, the card shows it, and send result posts the sheet to your study conversation. A paper has no say-it-back and no I think I'm right: if you believe an answer is marked wrongly, tell your study partner, which can draft a note for you to send to the people who made the course.

Writing code. A coding task fills the screen: the problem on the left, your code in the middle over a console, and your study partner on the right (three tabs on a phone); drag an edge between them to resize. Some tasks can be written in Python, TypeScript or JavaScript: a Language choice above the editor switches between them until your first Check (from then on the task is worked in that language), the task names its function as that language does, and the choice is remembered on that device for the next task. What you wrote in each language is kept apart, so switching loses nothing. The checks are the same in every language. TypeScript is run, not type-checked: its types are taken out and the code runs, so a wrong type does not stop it — only what goes wrong as it runs. The editor numbers its lines, colours the language, keeps your indentation (deeper after a colon in Python, after an opening brace in the other two) and closes brackets and quotes; Ctrl or ⌘ with / comments lines out and back. As you type it offers ways to finish the word — your own names first, then the language's; Tab takes one. Run shows in the console what your code printed, or the error; Check runs it against the task — the exact output it should print, or the course's own tests — and says what was off: for a test that did not pass, which one it was, what it ran, what it expected and what your code gave back. Ctrl or ⌘ with Enter runs; add Shift to check. A task that asks for input shows the lines it reads. A run is stopped after ten seconds. Start over puts the starting code back, after asking once more. You can give up and see a solution, in the language you were writing. The first Python run takes a few seconds while Python loads; TypeScript and JavaScript start at once.

Your code runs in your own browser and stays there unless you send it: only whether you passed, and in how many checks, is kept with your practice. What you were writing is kept in that browser, so leaving the workspace loses nothing; it is forgotten when you sign out, and another device starts from the course's code. Everything that comes with Python is there; add-on packages such as numpy are not. In TypeScript and JavaScript what the language itself has is there — no packages, and nothing on the web: the code cannot fetch anything.

Your study partner, beside your code. The panel on the right has Hint and Review my code while you work, Get feedback once your code passes, and a box for a question of your own. A hint is one nudge fitted to what you wrote, not the answer; ask again for a stronger one. Feedback says what is good, what could be better, and how to explain it in an interview. The buttons send your code, the task, and what your last run or check said. A question you type sends the same while with my code is ticked, and only your words and the task when it is not. Nothing is sent until you tap a button or send a question. It all goes to your own study conversation as messages from you, each counting like any other; the people who made the course do not see it. Code longer than 5,500 characters is not sent.

A mock interview. A coding problem can be an interview: the list of problems shows its length beside it, such as "45 min interview". Opening one shows neither the problem nor the editor until you tap Start the interview; the clock counts from that tap, and the study partner's panel is your interviewer instead. Starting an interview sends the task and not your code. Talk in the box as you would aloud: ask your questions, say your plan and what it costs. Show my code sends what you have written so the interviewer can ask about it — you get a question back, not a fix, and never whether it passes; you still run and check it yourself. End and debrief sends your code and what your last run or check of it said, and the interviewer writes you up as one would after a real round: problem solving, code, communication and testing, each strong, mixed or not yet, and what to practise next. It is practice, and says nothing about how a real interview would go. 🗣, beside the box once the interview has started, holds it aloud: conversation mode, as in a role-play — your words are written down and sent as you would type them, but never with your code; the interviewer's replies are read to you, and the microphone opens again after each. Your code goes only when you tap Show my code or End and debrief, and the debrief is shown, not read out. The debrief stops the clock, which then says the time you used. When the time runs out the clock says so and nothing is taken away. The clock is kept in your browser, so leaving the workspace does not hand the time back. Each sitting starts clean: when you finish one, its clock and the code you wrote are forgotten, and the next starts from the problem's own code.

The examples in a Python lesson run too: each has a Run button under it, and Edit to change it and run your version — like a notebook. If the example asks for input, a box under it takes the lines it reads. Nothing there is marked or kept. The study assistant cannot see the code you write in an example; to ask about it, paste it into the chat.

When you finish, the panel shows your score and the items you missed, and Send result posts them into your study conversation so the assistant can talk you through them. The course's owner does not see your results.

For the person writing the course: ask the project's chat to turn a chapter's practice into an activity. It checks every item as it files them and reports what to fix, so a mistake is caught before a viewer meets it. In a Japanese set that includes an answer written with kanji and no kana beside it: the set is turned back, naming the item, until the answer is given both ways or the item is marked as being about the writing itself. The same check runs when you edit a lesson's page yourself.

When learners press I think I'm right, the line at the top of the project's chat says how many answers wait for you, and opened it lists each: the lesson's practice, the item, what they typed, the answer it was marked against, and how many learners gave it — never who. Tell the chat which ones are right. It adds a right one to the set beside your answer, exactly as the learner typed it and checked like any answer you file, and the set keeps your answer first; one you say is wrong leaves the set as it is, and it is not asked about again unless you change that question or its answer. Your own run-through of a set never counts.

Practice has to be an activity. A chapter whose text has blanks typed into it, or more than two separate answer boxes, is turned back when the chat files it, with a note to make the practice an activity instead. One or two single questions may stay in the text as answer boxes. Chapters filed before 1 October 2026 keep their text as it is: ask the chat to turn their practice into activities.

A question your study partner asks you in the conversation itself comes with its own answer box. Kuyun checks every box before the message reaches you: blanks written as plain text are given a box, and a box that cannot be drawn is sent back to be written again. A question should never arrive without a place to answer it.

This is a page of Kuyun's own handbook, the one its assistant answers from — ask it in the app and it will say the same.