What a keyboard-level agent is
A keyboard-level agent lives in your terminal. It can read the files in your working directory, run commands, and propose edits. You stay in charge of what it does — it asks before touching things, and you approve each step.
The closest analogy is an overcaffeinated junior engineer sitting next to you who can read the codebase in seconds and type 100x faster than you can. They will propose things you would never think to propose. They will also propose things that are wrong. Your job is to stay the one driving.
The three commands you'll run 90% of the time
Across tools, the shape of the commands you actually use most is surprisingly consistent. Every terminal-native agent gives you some version of:
1. "Explain this."
Explain what handleSubmit in LoginForm.tsx does and what happens when
the API returns a 401.
You'll do this constantly the first week in any new codebase.
2. "Make this change."
Rename `cfg` to `config` everywhere under src/. Don't touch the tests
yet — I want to see the diff first.
Notice the second sentence. Constraining what not to do is usually more important than constraining what to do.
3. "Find the bug."
The /api/tutor route returns 500 on empty body. The stack trace shows
it's from .filter() on body.messages. Find the bug, propose a fix with
a test.
Notice the shape: symptom → observation → desired outcome. Not "please fix a bug."
What it can't do (yet)
A terminal-level agent is not a substitute for you in the following situations:
- Understanding product intent. It can see the code. It can't see your users, your roadmap, or why this feature exists.
- Making architectural decisions. It will happily propose a 6-file change when a 2-line config change would work. You need to steer.
- Knowing when to stop. An agent will keep proposing things until you say "that's enough." Good engineers stop early.
Homework
Open the repo for the project you're working on (or this course's starter repo). Run your keyboard-level agent inside it. Give it these three prompts, in order:
- "Explain the top-level structure of this repo in 5 bullet points."
- "Tell me one thing in this codebase you'd refactor, and why."
- "Find one bug or one fragile pattern. Don't fix it — just describe it in one paragraph."
Don't accept any changes. Just read what the agent says. Notice what it noticed that you didn't.
Next lesson: delegation as a skill. When to hand things off, and how to describe them so the agent gets them right on the first try.
Co-taught by Devin and Claude. Inspired by Anthropic's "Claude Code 101" and "Claude Code in Action".