How Spies (and Your Brain) Break Big Problems Into Tiny Pieces

Part 1

The Spy Problem

Imagine you're a spy and you need to send a secret message to your partner. If anyone reads it, your mission is over. So you need to encode the message — scramble it so only someone who knows the trick can read it.

That sounds hard, right? Where do you even start?

Here's the secret that every spy, every programmer, every great problem-solver knows: don't try to do the whole thing at once. Break it into tiny pieces. Solve each piece. Then put them together.

This is called decomposition, and it's the most important thinking skill you'll ever learn.

You Already Do This

Think about how you get ready for school in the morning. You don't just "get ready" — you wake up, brush your teeth, get dressed, eat breakfast, pack your backpack, put your shoes on, and walk out the door. That's decomposition. You break "get ready" into seven smaller steps without even thinking about it.

Today we're going to use this same skill to build something cool: a program that turns ordinary messages into secret codes. But first, we need to learn how to talk to a computer.

Part 2

Talking to a Computer

A computer doesn't understand English. It understands code — specific instructions written in a very precise way. The language we'll use is called Python, and it's one of the most popular programming languages in the world.

Let's start with the simplest possible thing: telling the computer to display a message on the screen. In Python, you do that with a command called print().

Click the ▶ Run button below to see what happens:

You just ran your first line of code! Let's understand what happened:

Now here's where it gets fun. That code up there? You can change it. Click inside the dark box, delete what's there, and type something different. Try making it say your name, like print("My name is Lena."). Then click Run again.

Go ahead: experiment. You can't break anything (as long as you don't accidentally delete the quotation marks or the parentheses — these are important for Python.).

Displaying Multiple Lines

You can use print() multiple times to display several lines. Each print() shows on a new line:

Try changing the agent name or the mission. Make it yours.

Part 3

Storing Information in Variables

So far we've just been displaying text directly. But what if you want the computer to remember something so you can use it later?

That's what variables are for. A variable is like a labeled box where you store information. You give the box a name, and you put something inside it.

The powerful thing about variables is that you can change what's inside them. Try changing "Shadow" to your own spy name and run it again.

Getting Input from the User

Right now, the spy name is written directly into the code. But what if we want the person running the program to choose their own spy name? Python has a command for that: input().

When you run this, a small popup will appear asking for your spy name. Type something in and click OK. The program then uses whatever you typed in the rest of the code.

Part 4

Text Is Made of Individual Letters

Now we know how to store and display text. But to build a secret code, we need to understand something deeper: text is made of individual characters, and Python lets you look at each one.

In Python, a piece of text (like "HELLO") is called a string. Think of a string as a row of small mailboxes, each holding one letter:

One important thing: computers start counting at 0, not 1. So the first letter is at position 0, the second at position 1, and so on. This is weird at first, but you'll get used to it.

We can access any letter in a string by using its position number, together with the square brackets. For example, word[2] gives us the third letter in the string (remember, counting starts from 0, so word[2] gives us L).

Try changing "HELLO" to your own name and see what's at each position. What happens if you try a position number that's too high?

Part 5

The Alphabet Is a Number System

Things are about to get interesting.

Inside the computer, every letter is secretly a number. The letter A is stored as 65, B as 66, C as 67, and so on. This system is called ASCII — it's the code computers use to represent letters. It stands for American Standard Code for Information Interchange.

Python gives us two commands to convert between letters and numbers: ord() and chr().

Go ahead and practice a bit. Find the codes for letters in your name.

Why does this matter for our secret code? Because if every letter is a number, we can do math with letters. For example, we can shift them forward. Or, we can scramble them. But most importantly, we can encode them.

Let's try — what if we take a letter and shift it forward by 3?

First, we'll define a variable called letter and give it some value (some letter). Then, we'll get the number for that letter using ord(). We'll create another variable called number, and add 3 to it (we put this into another variable called shifted_number), and convert it back to a letter using chr().

A becomes D! If we shift every letter by 3, then B becomes E, C becomes F, and so on. This is the Caesar cipher — a secret code invented by Julius Caesar over 2,000 years ago to protect his military messages.

Try changing the letter to "H" or "M" and see what it becomes when shifted by 3.

Part 6

Decomposing Our Secret Code Machine

Now we have all the building blocks. It's time to use decomposition — breaking the big problem into steps — to build our complete secret code encoder.

Let's think like a spy. What does our encoder need to do?

See? Five steps. Each one is something we already know how to do (or will learn right now). That's the power of decomposition — a scary problem becomes five friendly steps.

Step 1: Get the Message

We already know this — we use input():

Steps 2–4: Process Each Letter

Now we need to look at each letter, one at a time, and shift it. When you need to repeat an action for each item in a collection, you use a for loop.

It's simpler than it sounds. Let's see it first:

Now let's combine the loop with our letter-shifting trick:

This is now a slighly longer and more complex piece of code. So, you have to be more careful about indentation and structure. Make sure all lines inside a loop are indented the same amount, and that each line of code is in the right place.

Here, you learn an important programming trick: you can create empty variables and fill them up little by little. This is how you build up a result when you don't know it in advance — like when you're encoding a message, or calculating a score, or keeping track of a total. For example, if you wanted to count how many letters are in a message, you could start with count = 0 and then add 1 like this: count = count + 1 for each letter you see. This is a very common pattern in programming.

You also learn to check whether some things are true, like when you ask whether the message contains a space or a letter (answer this question: why is that important for encoding messages like this?).

Try it out with some other messages, like "WELCOME TO THE SECRET CODE CLUB" or "I AM A SPY". Play around a little bit before moving on to Part 7. Have some fun, make some encoded messages for your friends or family!

Part 7

The Complete Secret Code Machine

Time to put all five steps together. This is the payoff — your very own working secret message encoder:

Try encoding MEET ME AT NOON — it should become PHHW PH DW QRRQ.

Part 8

What You Just Did

Let's step back. You started with a vague, scary problem — "build a secret message encoder" — and you solved it by breaking it into five clear steps:

1. Get the message
2. Look at each letter
3. Shift each letter forward
4. Collect the results
5. Display the encoded message

Each step was manageable. Each step built on the one before it. And together, they created something genuinely useful — something you can use to send secret messages to your friends.

That's decomposition.

Thinking Questions

Talk these over with someone, or think about them for a bit:

1. How did breaking the problem into steps make it less scary?
2. What would have happened if we tried to write the whole program at once?
3. Can you think of a real-life problem you could decompose? (A big homework project? Planning a party? Learning a new skill?)

Challenges

Level Up

If you want to push further, try these. Each one requires decomposition — plan your steps before writing any code.

Summary

What You Learned