Big models cost a lot per run. Instead of asking them to execute right away, ask for the plan first, then the execution. Splitting into two steps cuts cost and lifts quality.
When you start a big task with AI, there's a scene that comes to mind. You open the best model, throw the hard job at it, and wait for the result. Most people work this way. Then a month later the bill is bigger than expected, and the output rarely lands on the first try. Why? The answer is in a surprisingly simple principle: the more expensive the tool, the more you plan before using it.
This essay explains that principle from start to finish. If you've never used AI before, you can still follow along — we'll go slowly. Today's example is Claude Opus 4.5 making a 3.js media art piece, but the principle applies to any AI tool, in any era. The names will change. The spine of this essay still holds.
Think about a carpenter. A skilled carpenter always draws the plan before cutting expensive hardwood. Cheap plywood is fine — cut it wrong, cut it again. But a walnut board costs hundreds of dollars, and one bad cut lands straight in your pocket. So first you write the measurements on paper, decide the order, and only then pick up the saw.
AI works the same way. Small models are fast and cheap — run it, if it's wrong, run it again. But a big model costs a lot per run and takes a while. So the sensible thing is to plan first, confirm, and only then execute. People have worked this way around expensive resources for centuries.
For some reason, the common sense disappears in front of AI. Why? Because AI looks like magic — one click and the answer appears. You lose the feeling that it's expensive. So you toss a hard task in one line and hit enter. The best model spits out 20 pages; you don't like it, you throw again; and again. That's the moment the bill explodes.
Let me give you a concrete scene. I recently opened Claude's biggest model, Opus 4.5, and tried to build a 3.js media art piece visualizing how the human mind thinks. What's 3.js? It's a JavaScript library that lets you draw 3D graphics in a web browser. Abstract concepts — memory, emotion, logic, intuition — became floating particles (thousands of tiny points). Hover the mouse on one and the rest dim, like focusing a single memory. Fairly complex work.
The first prompt I typed was this:
"I want to build a 3.js media art piece. Don't build yet. Tell me the plan first."
One extra line. "Tell me the plan first." That single line changed everything.
Opus didn't spit out a long output. Instead it handed me a short design doc — which skills to use (Algorithmic Art, Frontend Design), which concepts to visualize (300 memories, emotional waves, eureka moments, dream mode), how to keep performance (rendering thousands of particles at 60 frames per second). I read it, thought "okay, let's go this way," and then said "build it."
The easiest way to feel this is a hospital. When you go in for major surgery, the surgeon doesn't pick up the scalpel right away. First they show you the CT scan, explain where they'll cut, what recovery looks like, what the risks are. After you say "yes, I understand," only then does the surgery begin. Why? Because it's expensive. And because once you start, you can't undo it.
Treat expensive AI models the same way. Instead of reaching for the scalpel, listen to the explanation first, confirm, then start. In the 3.js media art work, what I saw during the planning step was exactly that CT scan. Opus declared up front that it would use two skills together — "Algorithmic Art" and "Frontend Design" — and even wrote down why it would switch from p5.js to 3.js. If I hadn't read that and nodded, I would've only noticed the wrong direction once we were deep into production. By then, the cost and the hours would've already been spent.
Let me show the difference with numbers. Opus 4.5 hit 80.9% on SW-Bench Verified, a coding benchmark — far ahead of the previous generation. There's a more interesting number. According to Anthropic's own announcement, Opus 4.5 reaches peak performance on complex tasks in just 4 iterations, while competing models needed up to 10 tries.
Here's the first aha moment.
A good model isn't the one that tries more — it's the one that needs fewer tries.
4 versus 10 is a difference of 6 runs. And even those 4, if you pull out the plan first, drop to one or two. Run Opus without a plan and what happens? One run, unhappy, another, another. The 6-run gap becomes 12, and the bill grows accordingly.
So how do you apply this? It's simple. Before throwing a big task into the input box, ask yourself one question:
"Is this task small enough to run in one shot?"
If the answer is no, ask for the plan first.
| Situation | Old way | New way |
|---|---|---|
| Summarize a 20-page report | Run it directly | Ask for the structure first → then run |
| Build a web app | "Build it" | "Tell me which skills / libraries you'll use" |
| Write a research paper | "Write it" | "Give me the outline and section arguments" |
All three rows are the same move: one call becomes two. And that split cuts cost and raises quality. Why? Because when Opus focuses only on "how to do it," the thinking sharpens. And because a human checks in the middle, you never spend an hour going the wrong direction.
Now the actual commands. Don't memorize anything — one sentence is enough.
Don't build yet. Give me the plan first.
Put that line in front of any big task. Claude, ChatGPT, Gemini — any AI will respond to it. In Korean it goes:
바로 만들지 말고, 계획부터 알려줘.
Once you have the plan, keep the parts you like and continue with:
Good. Proceed with the plan above.
Try this for just one week. It feels clunky at first — "why two steps instead of one?" But after a few days it becomes automatic. And you'll see the outputs get noticeably better.
Let's wrap up.
Expensive tools need design first. Carpenters, surgeons, architects — people have worked this way for centuries. AI is no exception. A big model costs a lot per run, so before running, pull the plan, confirm, then execute. One call becomes two. That's the whole move.
Three years from now, even if "Opus" stops being called Opus, the principle in this essay still works. Whatever company ships whatever model, the gap between expensive and cheap tools will always exist. And in front of expensive tools, planning always comes first. Tech changes. Principles don't.
Plan first. Confirm next. Execute last.