StarCode Handbook

Every picture in here is a real screenshot of the app. Download it as a PDF

Getting in

Go to starcoderobot.com and press "Open StarCode". StarCode then asks for a code: "Enter your code to continue". The code for this launch is STARKID. A student with a class code from a teacher types that code instead. Either one opens the app. The code is remembered on that device for a year, so it is typed once.

The language menu

The button that says "English ▾" opens the language menu, headed Input Language. It holds 22 languages: English, Spanish, French, German, Portuguese, Chinese, Japanese, Korean, Arabic, Hindi, Italian, Russian, Dutch, Turkish, Polish, Vietnamese, Bengali, Urdu, Indonesian, Marathi, Telugu and Thai. The whole app follows it: the categories, the titles, the buttons and every message. The blocks and the Syntax view do not change, because they are code, and code is written the same way in every language.

The coding view

Where you build a program. The toolbox and block canvas on the left, the real code in the middle with the monitor below it, and the StarCode Tutor on the right.

The control view

Where you build a controller for your robot. Drag sliders, buttons and joysticks onto the grid, and use them while your program runs.

The control view, widget by widget

A canvas of widgets a child lays out themselves, and drives the robot with while the program runs. The app sorts them into three groups: Input, Buttons and Monitors. Every widget comes in the same three sizes, and the Camera has two more. Every widget takes its color from the color picker, and the colors are the app's own: blue, teal, purple, orange, pink and white.

The top row

The panels in the coding view

The control view has its own parts, and they come later in this handbook.

Block View The whole left side of StarCode. The toolbox and the block canvas together.	Toolbox The strip down the far left. It holds all the categories. Not: library, palette, sidebar
Category One colored circle in the toolbox. Click it and its blocks slide out. Not: library	Block drawer The blocks that slide out when you click a category. Drag one onto the canvas. Not: menu, list
Block canvas The big dotted space where you drag blocks and join them together. Not: workspace, stage	Syntax view The panel that shows your program as real written code, with line numbers. Not: code view, output
Learn view Where you can ask the StarCode Tutor a question about your program. Not: AI panel, chat	Map Where you lay out your steps before you build them, and join them with lines. Free for everybody. Not: flowchart, diagram
Monitor Shows what is plugged into each port right now, and what the robot is measuring. Not: console, dashboard	Remote page The control view with its widgets. The button to swap to it is in the top left corner. Not: control view

The categories, one by one

In the order they sit in the toolbox, top to bottom.

The import lines, purple

Every import line is purple. Every robot has its own library, so every one uses its own words. The shape never changes. Examples: from ev3dev2.motor import LargeMotor, from pybricks.pupdevices import Motor, from machine import Pin.

The declaring lines, multicolored

The declaring lines are multicolored: each one is the color of the category its part belongs to. Each one makes a name. After that line, every block below can use the name instead of saying the port again. Again the shape is the same on every robot and only the words change. Examples: motorA = LargeMotor(OUTPUT_A), motorA = Motor(Port.A), tank = MoveTank(OUTPUT_A, OUTPUT_B).

The two groups in the drawer

Open the Imports drawer and you will see one clear gap. That gap is deliberate. Everything above it imports a tool, and it is all purple. Everything below it declares a part, and it is multicolored. Above them both sits a flat-topped block that starts the stack and writes nothing but a comment.

1Importing

the import lines

One block per part. The block brings every word that part needs, including the word for its port, so a motor block already has OUTPUT_A in it. The robot does not know the word LargeMotor until you ask for it, and this line asks. Two parts wanting the same line only get it once.

2Declaring

the declaring lines

Each of these makes a name, and you pick the name from the dropdown the same way you pick the port. Picking the name picks the kind of thing with it, so a gyro can never be declared as a touch sensor. After that line, every block below can use the name instead of saying the port again. Notice the colors: a declaring line is the color of the category the thing belongs to, so the line that declares a motor is Motor blue even though it lives here in Imports. Import lines are always purple, the color of Imports itself. The color tells you which of the two jobs a line is doing. The last two, the speaker and the lights, have no port in them, because they are built into the robot and there is only one of each.

Importing in all three languages

The Imports button

On the top row, to the right of the Java button, sits a solid purple button with white writing and a small down arrow. It says Imports in Python and Java and Include in C++. It is there while the program on the canvas is missing a line it needs, and it is gone when the program is complete. It does not matter how the lines got there: one press of the button, dragging the blocks out of the Imports category one at a time, or some of each. The button watches the program. It does not remember whether it was pressed.

One press puts every missing line in, as real blocks in the Imports stack, with their own dropdowns. A student can open them, change them, or throw them away. The Imports stack goes in above everything else on the canvas. It never writes a line the Imports category does not offer.

Before: a program with no Imports stack, and the note under the canvas naming what is missing

After one press: the Imports stack sits above everything else, and the note is gone

2. Events · yellow

Where a program begins.

Block	What it does
# Program start	The top of your program. Everything hangs underneath it
async def task1():	A second stack that runs at the same time as the first
# comment here	A note for a human. The robot ignores it completely

Why Program start is a comment in Python

Python needs no start line. It simply runs from the top of the file to the bottom, so in Python the Program start block writes only a comment, # Program start, and it is green like every comment. C++ and Java do need a start: the program begins inside a function with a special name, and everything the program does goes inside its curly brackets.

Language	The start line on the EV3	The start line on a bare board
Python	# Program start	# Program start
C++	int main() {	void setup() {
Java	public static void main(String[] args) throws Exception {	not offered

Events in C++ The EV3 in C++. The program starts inside int main().

Events in Java The EV3 in Java. The program starts inside main.

3. Motor · blue

Turning one motor, and asking it questions.

The blocks shown here are the EV3's. Every robot has its own words for the same jobs, and Part ten lists them all.

Block	What it does
.on(...)	Turn at a speed and keep going
.on_for_degrees(...)	Turn a set number of degrees, then stop
.on_for_seconds(...)	Turn for a set time, then stop
.stop()	Stop turning
.position	How far it has turned so far
.position = 0	Call where it is now zero

SPIKE Prime: why the category says group and the block says pair

A group can hold any number of motors, which is what you want for a robot with three or four wheels. But SPIKE Prime's own library only offers pairs, exactly two, so on SPIKE Prime the blocks say motor_pair. The category is the idea; the block is what that robot can really do.

Example: drive a square

A for loop that goes around four times. Each time the robot drives forward for 2 seconds, then turns.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
tank = MoveTank(OUTPUT_A, OUTPUT_B)

# Program start
for i in range(4):
    tank.on_for_seconds(SpeedPercent(50), SpeedPercent(50), 2)
    tank.on_for_degrees(SpeedPercent(30), SpeedPercent(-30), 180)

The same idea in all three languages

All three columns are the EV3's. This is where the languages look most different. The logic is identical every time; only the writing changes.

Example: drive until the color sensor sees red

The pointed question compares the color the sensor sees with the color red. The robot keeps driving while the answer is no, and stops when it is yes.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor import INPUT_3
tank = MoveTank(OUTPUT_A, OUTPUT_B)
color3 = ColorSensor(INPUT_3)

# Program start
while not (color3.color == ColorSensor.COLOR_RED):
    tank.on(SpeedPercent(30), SpeedPercent(30))
tank.off()

Yes and no questions

Working out a number

Working with words

Not every value is a number. These three work on words.

Example: beep every other second

count goes up by one every second. When count % 2 is 0, count is even, and the robot beeps.

EV3, Python

from ev3dev2.sound import Sound
import time
spkr = Sound()

# Program start
count = 0
while True:
    count += 1
    if count % 2 == 0:
        spkr.play_tone(440, 0.1)
    time.sleep(1)

Example: count, and watch it in the Monitor

x starts at 0 and goes up by one every second. print sends each new value to the Monitor, so you can watch the variable change while the program runs.

EV3, Python

import time

# Program start
x = 0
while True:
    x += 1
    print('x =', x)
    time.sleep(1)

The same idea in all three languages

All three columns are the EV3's.

9. Functions · red

Making your own block out of other blocks.

Block	What it does
def my_function():	Make a new block, and say what it does
my_function()	Use the block you made
return 0	Send an answer back to whoever called it

Example: one block that plays two notes

my_function plays a low note and then a high one. The program calls it twice, one second apart, instead of building the same three blocks twice.

EV3, Python

from ev3dev2.sound import Sound
import time
spkr = Sound()

def my_function():
    spkr.play_tone(440, 0.1)
    time.sleep(0.2)
    spkr.play_tone(660, 0.1)

# Program start
my_function()
time.sleep(1)
my_function()

Why this is worth learning early If you find yourself dragging the same four blocks over and over, make them into one block instead, and give it a name that says what it does.

10. Sound · bright pink

Making the robot play a sound.

Block	What it does
spkr.play_tone(440, 1)	Play a note at a pitch, for a length of time

Playing a note waits This is a blocking block. The program stops on that line until the note has finished, so a long note inside a loop holds everything else up.

11. Light · purple

Turning on the robot's lights and its display.

Block	What it does
leds.set_color('LEFT', 'RED')	Turn on one of the lights in a color

One block here, more on other robots The EV3 has two lights and nothing else, so it has one block. A robot with a display has more.

12. Timing · light blue

Measuring how much time has passed.

Block	What it does
_timer_start = time.time()	Begin counting from zero
(time.time() - _timer_start)	How long since it started, in seconds

Example: drive for 3 seconds, timed

The timer starts at zero. The loop keeps the motors on while less than 3 seconds have passed, then the motors stop.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
import time
tank = MoveTank(OUTPUT_A, OUTPUT_B)

# Program start
_timer_start = time.time()
while (time.time() - _timer_start) < 3:
    tank.on(SpeedPercent(50), SpeedPercent(50))
tank.off()

13. Remote · mint

The widgets you build on the remote control page, read by your program while it runs. Each block is the value of one widget, and it drops into any block that wants a number. They are the same on every robot and in every language.

Block	What it reads
remote_button_1	A button, pressed or not
remote_slider_A	Where a slider is
remote_wheel_A	How far the steering wheel is turned
remote_joy_A_x	One direction of a joystick
remote_dpad_x	One direction of the D-Pad
remote_toggle_1	A toggle, on or off
remote_space_x	One direction of the 6D Space

Example: a slider sets the motor speed

Slider A on the remote control page gives a number. The motor block reads it every time the loop comes around, so moving the slider changes the speed while the program runs.

EV3, Python

from ev3dev2.motor import SpeedPercent, LargeMotor, OUTPUT_A
motorA = LargeMotor(OUTPUT_A)

# Program start
while True:
    motorA.on(SpeedPercent(remote_slider_A))

Why it feels different from every other category Every other block tells the robot what to do. These let you tell it what to do while it is already running.

14. Circuit · red and blue

Wiring your own parts to a board, one pin at a time.

Circuit appears on robots with numbered pins, such as the ESP32, the Arduino and the micro:bit. The table and the picture here are the ESP32's, in Python.

Block	What it does
Pin(13, Pin.OUT)	Say whether a pin is listening or talking
Pin(13).value(1)	Turn a pin fully on or fully off
Pin(13).value()	Is this pin on or off
Pin(13).value() == 1	Is this pin on, yes or no
PWM(Pin(13)).duty(512)	Turn a pin partly on, for dimming or speed
ADC(Pin(13)).read()	Read a value that is not just on or off
PWM(Pin(13), freq=50).duty_ns(500000 + 90 * 11111)	Move a servo to an angle, here 90
buzzer = PWM(Pin(13), freq=440)	Make a buzzer sound
buzzer.deinit()	Stop the buzzer
time_pulse_us(Pin(14), 1)	Time a pulse, which is how a distance sensor on two pins is read

Example: blink an LED

Pin 13 is set as an output, then turned on and off every half second. Wire an LED and a resistor from pin 13 to ground to see it.

ESP32, Python

from machine import Pin
import time

# Program start
Pin(13, Pin.OUT)
while True:
    Pin(13).value(1)
    time.sleep_ms(500)
    Pin(13).value(0)
    time.sleep_ms(500)

Three whole programs

The tables above say what each block does. These are three finished programs, each one harder than the last. All three are on the EV3, so they match the pictures above. Every one has two stacks: the imports and declaring lines on one, and the program on the other.

Example one · the smallest program that works

Two import lines, one declaring line, and a motor that runs for one second. Five blocks. Two to bring in the tools, one to give the motor a name, two to use it.

Example two · adding a sensor and a question

One more import block, the one that writes two lines, and one more declaring line, because there is a second thing plugged in. In the program, a loop that keeps asking whether the touch sensor is pressed. Notice the pointed teal block sitting in the if: only a pointed block fits there, because only a question can be answered yes or no.

Example three · the parts with no port

Two more import lines and two more declaring lines, for the speaker and the lights. Those two declaring lines have no port in them, because there is only one speaker and one set of lights and they are built into the robot. In the program, the same question now sets off three things at once, and an else underneath stops the motor when the sensor is let go.

The motor seems to do nothing on is non-blocking, so stop runs straight away. EV3, Python from ev3dev2.motor import SpeedPercent, LargeMotor, OUTPUT_A motorA = LargeMotor(OUTPUT_A) # Program start motorA.on(SpeedPercent(50)) motorA.stop()

The motor runs for 2 seconds on_for_seconds is blocking, so stop waits its turn. EV3, Python from ev3dev2.motor import SpeedPercent, LargeMotor, OUTPUT_A motorA = LargeMotor(OUTPUT_A) # Program start motorA.on_for_seconds(SpeedPercent(50), 2) motorA.stop()

Example: drive until the touch sensor is pressed

INPUT_1 in the import line, INPUT_1 in the declaring line, and the touch sensor cable in port 1. The motors are on OUTPUT_A and OUTPUT_B, so their cables go in ports A and B.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import TouchSensor
from ev3dev2.sensor import INPUT_1
tank = MoveTank(OUTPUT_A, OUTPUT_B)
touch1 = TouchSensor(INPUT_1)

# Program start
while not (touch1.is_pressed):
    tank.on(SpeedPercent(40), SpeedPercent(40))
tank.off()

Line follower

Follows the edge of a dark line. When the sensor sees dark, the robot curves one way; when it sees light, it curves the other way, so it zigzags along the edge. This is bang bang control. Measure your own threshold instead of 40.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor import INPUT_3
tank = MoveTank(OUTPUT_A, OUTPUT_B)
color3 = ColorSensor(INPUT_3)

# Program start
while True:
    if color3.reflected_light_intensity < 40:
        tank.on(SpeedPercent(10), SpeedPercent(40))
    else:
        tank.on(SpeedPercent(40), SpeedPercent(10))

Line follower, smoother

error is how far the reading is from the threshold. The robot turns a little when error is small and a lot when it is big. This is proportional control, the first part of PID, and it follows the line far more smoothly.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor import INPUT_3
tank = MoveTank(OUTPUT_A, OUTPUT_B)
color3 = ColorSensor(INPUT_3)

# Program start
error = 0
while True:
    error = color3.reflected_light_intensity - 40
    tank.on(SpeedPercent(25 + error * 0.5), SpeedPercent(25 - (error * 0.5)))

Obstacle avoidance

Drives forward. When something is closer than 20 cm, it turns on the spot, then carries on.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import UltrasonicSensor
from ev3dev2.sensor import INPUT_4
tank = MoveTank(OUTPUT_A, OUTPUT_B)
dist4 = UltrasonicSensor(INPUT_4)

# Program start
while True:
    if dist4.distance_centimeters < 20:
        tank.on_for_degrees(SpeedPercent(-30), SpeedPercent(30), 180)
    else:
        tank.on(SpeedPercent(40), SpeedPercent(40))

Obstacle avoidance, advanced

When something is close, the robot stops, backs away, and turns. turns counts how many times it has turned, and turns % 2 makes it turn left one time and right the next, so it does not get stuck turning into the same corner.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import UltrasonicSensor
from ev3dev2.sensor import INPUT_4
tank = MoveTank(OUTPUT_A, OUTPUT_B)
dist4 = UltrasonicSensor(INPUT_4)

# Program start
turns = 0
while True:
    if dist4.distance_centimeters < 25:
        tank.off()
        tank.on_for_seconds(SpeedPercent(-30), SpeedPercent(-30), 1)
        turns += 1
        if turns % 2 == 0:
            tank.on_for_degrees(SpeedPercent(-30), SpeedPercent(30), 200)
        else:
            tank.on_for_degrees(SpeedPercent(30), SpeedPercent(-30), 200)
    else:
        tank.on(SpeedPercent(40), SpeedPercent(40))

Sumo

Waits 3 seconds, as the rules require. Then: if the color sensor sees the white edge of the ring, back away and turn. Otherwise, if the other robot is closer than 50 cm, push at full speed. Otherwise, spin to search for it. The order of the questions matters: staying in the ring comes first.

EV3, Python

from ev3dev2.motor import SpeedPercent, MoveTank, OUTPUT_A, OUTPUT_B
from ev3dev2.sensor.lego import ColorSensor
from ev3dev2.sensor import INPUT_3
from ev3dev2.sensor.lego import UltrasonicSensor
from ev3dev2.sensor import INPUT_4
import time
tank = MoveTank(OUTPUT_A, OUTPUT_B)
color3 = ColorSensor(INPUT_3)
dist4 = UltrasonicSensor(INPUT_4)

# Program start
time.sleep(3)
while True:
    if color3.color == ColorSensor.COLOR_WHITE:
        tank.on_for_seconds(SpeedPercent(-50), SpeedPercent(-50), 1)
        tank.on_for_degrees(SpeedPercent(40), SpeedPercent(-40), 300)
    elif dist4.distance_centimeters < 50:
        tank.on(SpeedPercent(100), SpeedPercent(100))
    else:
        tank.on(SpeedPercent(30), SpeedPercent(-30))

The browser comes first

This is the most common problem there is, and it is not a StarCode limit. The app opens and works in any browser. It is the connection to the robot that does not.

On a tablet

Everything is smaller on a tablet: the two top rows, the category column and the panel buttons. All fourteen categories fit down the side on an iPad held sideways, and both top rows use one button size, the way a computer does. The Full screen button gives StarCode the whole screen.

Connecting each robot

Installing from inside the app

Press Connect. Under USB cable and Bluetooth is the install line, and it goes over the USB cable. On the ESP32 it reads Install StarCode, and puts StarCode's own firmware on the board. The micro:bit has two install choices of its own: Install for USB cable puts MicroPython on it, and Install for Bluetooth puts the Bluetooth build on it. The EV3 and SPIKE Prime have no install line. The files ship with the app, so nobody opens the Arduino IDE. A bar shows how far it has got, and a board that is not an ESP32 is refused rather than written to. A board with nothing on it is noticed on connecting and offered the firmware, instead of sitting there looking connected and doing nothing. This is a grown-up job that happens once.

Naming a board, for a room with twelve of them

The Name button sits beside the robot's name in the middle row, and opens Name this board. On an ESP32, type the number on the board's sticker, 1 to 99, and it calls itself StarCode 07 in the Bluetooth list from then on. The number survives being switched off, so it is set once when the kit is unpacked. The board restarts afterwards. An EV3 can be renamed the same way, because its own firmware takes a name and broadcasts it. A micro:bit cannot be renamed by anybody, so the button shows the five letters it was given instead, the same five letters on its own screen. A SPIKE Prime shows the name it already has.

What each robot shows on itself

A robot with a light or a screen says what it is doing, and each state looks different from across a room, so a teacher with twelve robots can see which one is waiting and which one has gone wrong without walking over.

Stop

Stop is deliberately not something a student builds out of blocks, because a stop that runs through the program only works while the program is working. It ends the program and then switches the motors off, since ending a loop on its own leaves a motor turning at its last speed. Stop is pink, the same pink as an error line and a block that cannot work, so a child only has to learn one color for look here. On an EV3, the Escape button on the EV3 ends a downloaded program and stops the motors too.

When a robot is disconnected

When a robot is disconnected, StarCode releases it at once. The Monitor shows that the board is unplugged, Run no longer shows the program as running, and the Connect button returns to Connect. A motor or sensor disconnected from a port is removed from the Monitor when the robot's firmware reports it.

Run and Download

Run starts the program while the robot is connected to StarCode. Download stores the program on the robot itself, so it runs with no computer attached. If a robot cannot download yet, the Download button says so when it is pressed.

The three buttons

The same on every robot. Each one says what it makes, and its arrow points the way the program travels across the screen.

Numbers are held inside what the robot allows

Type 600 into a place that only goes to 100, press enter, and it comes back as 100. Every limit is read from the robot's own reference, so a light level on the micro:bit stops at 9 and the same idea on SPIKE Prime stops at 100.

Pasting a program in

The Syntax view takes typing and pasting from the moment a language is chosen, and an empty one says so. A paste is stripped to plain text, so nothing carries over from wherever it was copied. Edit it, press Generate blocks again, and the blocks follow the change. The import lines become their own stack on the canvas, the way a child builds them, and every stack is laid out in the order it was pasted.

Running a program without a computer

A program that has been downloaded is stored on the robot and runs with no computer attached. A program started with Run needs the robot to stay connected to StarCode. Part four explains Run and Download.

What it draws on

StarCode's Tutor is not a general chatbot pointed at robots. It draws on four separate bodies of work.

What it can teach, first day to last

The concepts run from the first day forward: sequencing, loops, if and else, variables and data types, functions, arrays, events, and debugging as a skill of its own. Then sensors and what each one can actually tell you, motors, encoders and gear ratios, parallel programs running two things at once, and combining more than one sensor to decide what to do. At the far end, closed loop control and PID, state machines, autonomous and driver controlled programming, and machine learning: object, face and audio recognition, supervised learning, and the sense, think, decide, act, learn loop that turns an AI decision into a robot actually moving.

What it can see

Every time a student writes to it, StarCode sends it two things: the code on that student's canvas, and the exact list of blocks that student's robot can run.

It helps with the wires too

Most of the time a robot that does nothing is not a coding problem. It is a wire in the wrong hole, a motor in a port the program is not using, or a part that was never working. The Tutor knows about both sides. It can walk a student through wiring an LED the right way around, the three wires on a servo and why only one of them carries instructions, which port a motor belongs in, and how to prove a part works before blaming the program.

How it teaches

It gives a hint before it gives an answer, and it will not write a student's program for them. Its first message is always the same question, "What would you like to learn?" It does not offer a menu. If a student says they do not know what to do, it looks at what they have already built and suggests one thing, not a list.

It teaches the line StarCode writes, not a block word. A student who says "repeat until" is told once that it is while not in written code, and from then on the Tutor says while not.

Every answer can be read out loud

Every answer has a speaker under it that reads it out loud, in the student's own language from the language menu. The Tutor is told never to write emojis, and anything that slips through is taken out before the answer is read, because the voice would read a picture out by its long name.

What it refuses

Anything that is not StarCode, the program, or the robot. Homework in other subjects, stories, games, films, music, sport, famous people, the news, jokes, personal questions about the student or about itself, shopping, and other students.

The reply is always the same shape: one short friendly line saying it only helps with coding here, then a question about what they are building. It will not answer partly, briefly, or as a joke, and it will not hint toward an answer.

If a student writes something worrying

The Tutor does not counsel them and does not continue the conversation. It says kindly that this is something to tell their teacher, their parent, or another trusted adult, and stops.

What you can and cannot see

You can see that a student has been using the Tutor, and roughly how much, in the progress record in the portal. You cannot see what was said. The conversation is not stored anywhere. It exists on the student's screen while they are working and is gone when the window closes. StarCode records only that a conversation took place and when.

The two switches

In the portal, next to each student's name, there are two switches: AI Learn and Imports button. Each is set for one student at a time. AI Learn is on when a class starts. Imports button is on for every student until a teacher turns it off.

AI Learn: turn it off and the Learn button disappears from that student's screen, so they are not tapping something that does not respond.

Imports button: purple means on, grey means off. Turn it off and that student does not see the Imports button at all, so they find the missing lines themselves. The button in the app never changes color.

Generate syntax + blocks has no switch of its own. It lives inside the conversation, so it is on when AI Learn is on and off when AI Learn is off. Even with Learn on, it stays asleep until the Tutor decides there is a good reason to offer it, so it cannot be used as a shortcut on every task.

Say this out loud to your class

Once, at the start of a course, say these three things.

The teaching opportunity in it

There is a computer science standard, MS-PRO-RD-03, about students examining code an AI wrote and identifying its strengths and limits. The Tutor is a way to teach that directly.

What is free and what is paid

Pressing Learn or Portal opens the plans panel, "Unlock Learn and the portal". The card is taken by Stripe, on Stripe's own page.

The plans

Teacher is for up to 12 students. Parent is for up to 2 children. Just me is for one person, over 18. AniBot is listed in the plans panel but is not for sale. Its card says "+ Add ons coming soon" and cannot be pressed.

Access codes

Paying makes a code. It is shown on screen straight after paying, and emailed from starcode@starcoderobot.com to the address used at the checkout. Type it into the app to switch the paid parts on, and into the portal to see progress.

The portal

At starcoderobot.com/portal, type the code. Before signing in it just says Portal. After signing in it names itself for whoever bought it: Teacher Portal, Parent Portal, or My Progress.

Cancelling, invoices and changing a card

In the portal, click "Subscription and invoices", at the bottom of the classes screen. That is Stripe's own page: cancel, change the card and download every invoice there. Cancelling ends at the end of the month already paid for, not on the spot.

The buttons, by their exact names

Remote, Undo, Reset, Skins, Handbook, Full screen, Install and Logout across the top. Python, C++ and Java, Portal, Name, Connect, Download, Run, Stop and Save across the second row. Under the block canvas, Generate syntax. Under the Syntax view, Generate blocks. Under the Learn view, Generate syntax + blocks.

The skins

StarCode Dark and StarCode Light. Never dark mode or light mode.

The Map

A step is one colored rectangle. A wire is a line joining two steps. The step being worked on wears a thin magenta ring, deliberately a color no step can be.

How a block is named

A block is always named by the exact code on its face, such as while True:. Never by a description like "the loop block".

The three Pythons, which are not the same Python

Say which one. Python on its own is only correct for the full one.

The robots, by their exact names

Never say "the hub". It means nothing on its own, because every one of these has a hub.

Port never means a connection

A port is a port on the robot. On the ESP32 the same idea is a pin. Those are the only two meanings we use.

Ways of talking to a robot

Live control is required on every robot. That is a decision, not a preference.

The monitor sections

By their headings: PORTS on a robot with ports, PINS on the ESP32, then REMOTE, VARIABLES, and the robot's own line at the bottom. The headings translate with the language; the meanings do not change.

The tutor

The circuit parts

Each part is called what is printed on it or what it is sold as: LED, resistor, breadboard, jumper wire, servo, potentiometer. No invented names, the same rule as everywhere else.

Programming

Robotics and control

Electronics and math

The rules, by name

The Language Parity Rule is about blocks, not about the language buttons. The buttons show what a robot can run, and the reason a language is missing differs from robot to robot.

The panels, the categories and the code words

Taught in parts one to four, listed here so every word is in one place.

SPIKE Prime

micro:bit

ESP32

EV3

Arduino