Your role: you chain the steps by hand.
Rung 2 begins the moment you notice you are typing the same kind of request for the third time. The defining move: stop treating each chat as a one-off performance and start treating your prompts as reusable assets — templates you save, refine, and chain together.
The box is still sealed. No tools, no reach into the world. What changes is not the model's capability but your relationship to the task: you decompose it into steps, build a template for each step, and run the steps in sequence — with you personally carrying the output of one step into the input of the next.
Three shifts happen at this rung, and together they are the difference between "using a chatbot" and "having a workflow":
Decomposition. A recurring task stops being one big ask and becomes named stages. "Write my weekly summary" decomposes into gather notes → summarize → format as email. Each stage gets its own template, tuned to do one thing well. Small, single-purpose prompts beat one sprawling mega-prompt — a lesson that returns at rung 5, where it reappears as the reason multi-agent systems exist.
Templates. A prompt template is a saved prompt with blanks: the instructions, the role, the format spec, and the examples stay fixed; this week's material drops into the slot. Templates convert your rung-1 iteration from a cost you pay every time into an investment you make once. Every time you refine the template instead of the one-off answer, you are compounding.
Structured output. Once a prompt's output feeds another prompt, sloppiness stops being tolerable. You start demanding structure: "return exactly five bullets," "output a table with these three columns." Structured output is what makes chaining possible — step two can only consume step one's output reliably if step one's output has a reliable shape.
There is a formal name for the skill you are building: context engineering — deliberately curating what goes on the model's desk, rather than wordsmithing individual requests. Your templates are context-engineering artifacts: each one is a considered decision about what the model needs to see, in what order, with what examples. The term was introduced in the Context pillar; rung 2 is where it stops being theory and becomes your actual practice.
At rung 2 you are the wiring between every step: copy out of step one, paste into step two, copy out of step two, paste into the email. Every Friday. By hand.
Do not rush past this friction — it is load-bearing for the whole ladder. The copy-paste tedium you feel at rung 2 is the honest, felt-in-the-hands answer to a question that matters enormously at rung 3: why would anyone give an AI tools? Not because tools are futuristic — because you are currently doing, by hand, mechanical transport that contains no judgment. Moving text between boxes is not judgment. Noticing that is what makes the next rung legible.
Judgment moves up one level: from evaluating each answer to designing the pipeline — deciding how the task decomposes, what each stage's template demands, what structure flows between stages. You still verify outputs (that instinct never retires), but you now also judge the system that produces them.
It's Friday again, but this Friday is different: you're not composing prompts from scratch. Three weeks ago you noticed you were writing the same requests every week, and you did rung 2's defining move — you saved them. You now have three templates in a notes file:
The Friday routine: find the articles (still you — sealed box), paste into template 1. Copy the five bullets, paste into template 2. Copy the ranked bullets, paste into template 3. Copy the finished email into your mail client, address it, send it.
Each template is better than anything you'd improvise, because each has absorbed weeks of refinements. When the summary bullets came out vague two weeks ago, you didn't just fix that answer — you added "every bullet must name its source article" to the template. The fix is permanent. That's the compounding.
The demand for structure appeared on its own. "Exactly five bullets" isn't fussiness — template 2 consumes template 1's output, and chaining only works when the handoff has a fixed shape. The moment prompts feed prompts, structured output stops being optional.
You are the wiring. Count the copy-pastes: article text in, bullets out, bullets in, ranked bullets out, ranked bullets in, email out, email into the mail client. Seven manual transfers, every week, none of which involve a decision. The judgment in this task — is the summary accurate? is the ranking sensible? should this go to the team? — is maybe two minutes of it. The wiring is the rest. Sit with that imbalance. Rung 3 exists because of it.
A concrete benchmark for the rung: a saved template pipeline for a real recurring task of yours (on the order of notes → summary → formatted email), run end-to-end manually, that produces better output than improvising ever did.
You reuse instead of rewriting — and you feel the copy-paste friction.
Two halves, both required. The first half is the capability: your refinements accumulate somewhere permanent. If every week starts from a blank chat, you are still at rung 1 with good habits. The second half is the judgment — and it is the unusual one, because it is a feeling. You should be able to look at your Friday routine and point precisely at which parts are judgment (evaluating, deciding, approving) and which parts are mechanical transport that happens to pass through your hands. If the routine feels perfectly fine and complete, you are not ready for rung 3, because you will not understand what problem tools solve. The friction is the tuition; make sure you actually paid it.
Prompt template. A saved prompt with slots: fixed instructions, role, format spec, and examples, plus a blank where this time's material goes. The unit of reuse — refinements go into the template and compound, instead of evaporating with the chat.
Decomposition. Breaking a recurring task into named stages, each handled by its own focused prompt. Small single-purpose prompts outperform one sprawling mega-prompt — a principle that echoes all the way up to rung 5's multi-agent designs.
Prompt chaining. Feeding one prompt's output into the next prompt's input to run a multi-step pipeline. At this rung the chain's connective tissue is you, copying and pasting.
Structured output. Output in a demanded, exact shape — "exactly five bullets," a fixed-column table, a fill-in template. What makes chaining reliable: a step can only consume the previous step's output if that output has a predictable form.
Context engineering. The real name for the discipline you are now practicing: deliberately curating what goes on the model's desk — which instructions, which examples, which material, in what order — rather than wordsmithing one-off requests. Successor to "prompt engineering." Introduced conceptually in the Context pillar; made concrete by your templates.