Let the agent gather context
You paste files, errors, and docs by hand every time, tedious, and you guess wrong half the time.
The idea inside
Give the agent tools and a clear goal and it fetches its own context, exactly what it needs.
After this lesson
You can explain why letting an agent retrieve its own context often beats pasting it by hand, and when each wins.
Where it leads
But every fetch spends tokens, so awareness of the budget starts to matter.
Inside this lesson
That's the real lesson stage, paused. Claim your pass to operate it.
See how AI actually works, end to end.
This lesson is one stop on the full arc. Unlock all of it, and keep it for life.
What you get
- The 34-lesson main path, a finishable route from a word to agents
- Goal tracks for using AI at work and building AI features
- Boss labs that make you apply a whole act, not just recognize it
- Spaced recall that brings each idea back before you forget
- Course memory: every term defined, with links to where it first appears
- A shareable capability card when you finish the main path
- Lifetime access on every device, every future lesson included
Not videos to watch. You predict, operate the machine, then prove it. That is why it stays.
99 interactive lessons and challenges. No videos, no code.
Free launch pass: lifetime access, no card needed
New here? The first lessons are free to try. Start with lesson 0.1
What this lesson shows
Give the agent tools and a clear goal and it fetches its own context, exactly what it needs.
The question it opens with
You paste files, errors, and docs by hand every time, tedious, and you guess wrong half the time.
The walkthrough, in the lesson's own words
- One task, two pickers: you paste files up front, the agent searches just-in-time. Tap a file to paste it.
- Grow the drive, then hand the agent a vague goal and watch what it drags in.
- Who selects the context is the lever: a clear goal plus tools beats guessing up front.
- Tap a file on the left to paste it. Blue files are on-task; red files are filler the model just reads past.
- There it is: hand-paste scoops up whole files just in case, so the bar bloats red with filler. The agent searched, opened only the matches, and stayed tidy green.
- All on-task so far. But a real paste grabs whole files just in case, tap a red one and watch the bar bloat with filler.
- With a clear goal the agent touches 2 files no matter how big the drive grows.
- Same tools, sloppy haul: "invoices" matched half the drive, so the agent dragged in last quarter's files and never ran the check. Tools don't rescue a vague goal, scoping the goal is the lever.
- Every irrelevant file is filler the model reads past, the rot from lesson 6.3. The agent skipped it by fetching just the matches.
- The real lever is who selects the context. Hand the agent a clear goal plus tools and it searches just-in-time, small and on-task. Hand it a vague goal and it junk-grabs, same as a manual dump.
- The verbs are search, open, and check: search the drive for the goal's own words, open only the matches, run the check to see the real number. The window stays small and on-task, dodging the context rot from lesson 6.3.
- In a coding agent the same verbs are grep (find the matches in the code), read (open only the matched files), and running the tests. Same loop, different desk.
- If the context is tiny and you already know exactly which two lines matter, pasting them is faster than a tool round-trip. Hand-feed when context is small and known; hand the agent the goal when it isn't.
- Two assistants dig into the same billing question over a huge shared drive. The one handed the whole drive answers worse than the one handed a clear goal and a search tool. Why?
- It's about who selects the context. Dumping the drive floods the window with filler the model reads past, context rot. A clear goal plus tools lets the agent search just-in-time and open only the matches, at the cost of a few tool calls and a couple thousand tokens, usually a good trade. Keep the goal specific: hand it a vague one and the agent grabs junk too.
Key takeaway
Stop spoon-feeding context: a goal plus tools beats a giant manual paste, and dodges context rot.
What you can do after this lesson
You can explain why letting an agent retrieve its own context often beats pasting it by hand, and when each wins.
Check yourself: Instead of pasting files by hand, a capable agent…
- Fetches its own context with tools (search, read, run)(correct)
- Memorizes your whole repo forever
- Needs no context at all
- Trains itself on your files
A capable agent gathers what it needs with tools (search, read, run), so you don't hand-feed files. It pulls minimal, relevant context itself.
Where it leads: But every fetch spends tokens, so awareness of the budget starts to matter.
This is the written summary. The lesson itself is interactive: you predict, drag and operate the mechanism above, and the reveal answers you.