Free · structured · practical
Search 中文 Start at lesson 1
Courses/Recursion and Divide-and-Conquer/Recursion: Break a Big Job into the Same Smaller Job
Programming Fundamentals · Algorithms Behind AI

Recursion: Break a Big Job into the Same Smaller Job

Walk a directory tree, break down tasks, draw a fractal tree—same playbook: call yourself. Watch an Agent recursively split “build a site” into actionable small jobs

THE QUESTION THIS PAGE ANSWERS

ANSWER FIRST

What is the key idea behind “Recursion: Break a Big Job into the Same Smaller Job”?

Walk a directory tree, break down tasks, draw a fractal tree—same playbook: call yourself. Watch an Agent recursively split “build a site” into actionable small jobs

DECISION RULE

Make the claim earn its place. Use this page as a decision aid, not a definition to memorize. Connect the idea to one real task, one observable result, and one failure that would change your mind.

TRY NEXT

Write one question you could answer with evidence after trying this idea.

WATCH FOR

A conclusion that sounds complete but leaves the key assumption untested.

Play a round · Help the Agent break down tasks

The boss drops one line: “Build a site for the bubble-tea shop.” You can’t start hands-on—but you can split. Click the cards below and peel the big job layer by layer until you hit ✋ “ready to do” leaf tasks, then hit “Start work.” Watch two things: splitting unfolds top-down; when work finishes, green “bubbles up” bottom-up back to the root.

Click the top big task first and split it open
See it? “Build a site” and “build the home page” are the same kind of problem—just smaller. The method for splitting “build a site” (cut into chunks, keep splitting each) lands unchanged on “design pages.” Using the same method on the same class of problem as it gets smaller—that’s recursion. Agent task breakdown, walking folders (folders inside folders), cascading KPIs at a company—same playbook.
Look again · one rule draws a tree

Recursion’s magic: one rule, unboundedly complex results. This tree’s entire manual is one sentence (under the figure). Drag the slider to deepen “split levels,” and watch: every new branch is a shrink of the last—the rule never changes, only the scale.

🌱 The whole rule: draw a branch, fork two at the tip, each fork is a “smaller you”—return to the start of this rule.
2 levels 3 branches total
“Calling yourself” means exactly this.The last step of “draw a branch” is to run “draw a branch” again. A recursive function in code looks the same: the last line of the body calls itself, with a smaller problem. Depth 8 is 255 branches—one rule, one big tree.
Concept card · Recursion trio

Those two demos hide all three requirements of recursion. From now on, check any recursion against these three:

1

Same kind of work

“Build a site” and “build the home page” are the same class of problem, so the same split method works. If the subproblems are a totally different kind of thing, recursion doesn’t apply.

2

Smaller scale

Each split must make the problem a notch smaller: whole site → three sections → one page. Every fractal fork is shorter than its parent. If it doesn’t shrink, you’ll never finish splitting.

3

Base case

When you hit a ✋ “ready to do” leaf, you must stop. This is the deadly one—you saw it in the sister chapter on stacks: each deeper recursive call stacks another frame; no base case means Stack Overflow.

One more layer on the AI connection: Ask an Agent to “refactor the whole project,” and it lists subtasks; if “refactor the login module” is still too big, it keeps splitting—until every item is an actionable “edit one file.” The moment it decides “small enough to do” is its base case. Next lesson you’ll see that merging the split results back together is exactly the idea behind context Compaction.

The algorithmic cost curve in “Play a round · Help the Agent break down tasks”

“The boss drops one line: “Build a site for the bubble-tea shop.” You can’t start hands-on—but you can split .” is not asking you to memorize steps. It trains you to spot repeated work: as the input grows, how many comparisons, moves, or recursive calls does the program perform?

Find repeated work before declaring something fast

Break “Recursion’s magic: one rule, unboundedly complex results .” into three questions: how input size changes, what each round does, and whether the next round can shrink its search space. Big-O describes growth, not an exact time on every machine; constants, memory, and data distribution still matter.

  • Recursion = isomorphic breakdown : same method, same class of problem, getting smaller as you go
  • Split top-down; results bubble bottom-up : when leaves finish, green bubbles all the way back to the root
  • The trio is all-or-nothing : same kind of work, smaller scale, base case

Theoretical optimum is not always practical optimum

When AI writes an algorithm, trace a small input by hand and benchmark progressively larger inputs. That turns “When you hit a ✋ “ready to do” leaf, you must stop .” from a slogan into a performance claim you can check.

From “Play a round · Help the Agent break down tasks” to “Look again · one rule draws a tree”

“Play a round · Help the Agent break down tasks” grounds the problem in “The boss drops one line: “Build a site for the bubble-tea shop.” You can’t start hands-on—but you can split . Click the cards below and peel the big job layer by layer until you hit ✋ “ready to do” leaf tasks…”. “Look again · one rule draws a tree” then moves it toward “Recursion’s magic: one rule, unboundedly complex results . This tree’s entire manual is one sentence (under the figure). Drag the slider to deepen “split levels,” and watch : every new branch is a shrink of the…”. Together, they show that the lesson is not just a conclusion to remember, but a claim with conditions.

Carry the judgment into the next situation

For a real task, find the repeated work first, ask how input size changes, and use a small benchmark to verify the theoretical judgment. Complexity should not become a label detached from the situation.

  • “Play a round · Help the Agent break down tasks”: The boss drops one line: “Build a site for the bubble-tea shop.” You can’t start hands-on—but you can split . Click the cards below and peel the big job layer by layer until you hit ✋ “ready to do” leaf tasks…
  • “Look again · one rule draws a tree”: Recursion’s magic: one rule, unboundedly complex results . This tree’s entire manual is one sentence (under the figure). Drag the slider to deepen “split levels,” and watch : every new branch is a shrink of the…
  • “The closing point”: Agent task breakdown, walking directories, fractal trees —everyday real faces of recursion

The final “The closing point” brings the discussion to “Agent task breakdown, walking directories, fractal trees —everyday real faces of recursion”. The useful thing to carry forward is knowing which judgments must be revisited when input, scale, or risk changes.

What this lesson wants to share

  • Recursion = isomorphic breakdown: same method, same class of problem, getting smaller as you go
  • Split top-down; results bubble bottom-up: when leaves finish, green bubbles all the way back to the root
  • The trio is all-or-nothing: same kind of work, smaller scale, base case
  • No base case = Stack Overflow: echo of the sister chapter’s stack—every recursive layer sits on the stack
  • Agent task breakdown, walking directories, fractal trees—everyday real faces of recursion
Mark as learned Your reading progress updates automatically
← PreviousNext →

Keep reading

The next useful article in the thread.

Recursion and Divide-and-Conquer · InteractiveDivide and Conquer: The Algorithm Behind Context CompressionCompaction in the AI Practicum is really divide and conquer: split a long chat, summarize each chunk, then merge. Run recursive summarization yourself and watch information compress layer by layerSearch and Sorting · InteractiveSorting's Real Face in AI: RerankPassages RAG retrieves can't go in as-is: coarse ranking first, then fine ranking. Tweak the weights yourself and watch candidates reshuffle—feeds and search results work the same waySearch and Decision · InteractiveBFS and DFS: How an Agent Finds Files in a CodebaseWatch two search personalities in a maze animation: sweep layer by layer vs go all the way down one path; Coding Agent grep and web crawlers are variants of bothSearch and Sorting · InteractiveBinary Search: The Optimal Number-Guessing GamePlay a 1-to-100 number-guessing round and feel the range cut in half each guess; a billion items found in 30 tries—how fast log n really is

ARTICLE DISCUSSION

Leave one useful thought here.

Keep the idea that clicked, the question that stayed open, or a small note for the next learner.

↗
Discussing Recursion: Break a Big Job into the Same Smaller Job Algorithms Behind AI
3discussionsArticle discussion · synced with the Circle
View in the learning circle
AM
Asha MorganContent editor
INSIGHTField note

I turned one judgment from this article into a small experiment I could run today. Knowing what to observe next is more useful than simply remembering the conclusion.

ARTICLE DISCUSSION7 helpful
LH
Lin HarperIndie developer
INSIGHTInsight

After reading this, I first looked for the conditions behind the idea instead of copying the method into a project. That order made the later trade-offs much clearer.

ARTICLE DISCUSSION5 helpful
KM
Kiki MooreProduct operations
QUESTIONQuestion

When this judgment reaches real work, which constraint should be added first? I am curious which step matters most between reading and the first practical attempt.

ARTICLE DISCUSSION4 helpful