12. Why Is It Important to Request Work in Small Units?

Check Message

Beginners drunk on the speed of vibe coding often bundle massive sets of features into a single prompt and send it to the AI. However, giving instructions in giant blocks disperses the AI’s focus and is a shortcut to tangling up code so that it spews out errors. When assigning work to AI, you must break down your requests into “small units” that can be completed in a single day or even just a few hours. This is the most fundamental safeguard to defend the context window—the AI’s technical limit—and to maintain human control over the system.

Characters

Mason: A novice developer who firmly believes that “since AI computes fast, assigning lots of work at once is efficient,” cramming a giant feature specification into a prompt all at once.

Sophia: A 10-year veteran developer who understands the limit of output tokens AI can generate at once as well as its focus degradation, instructing by breaking features down into atomic units.

Daniel: A project manager who proves that “Task Decomposition”—breaking work into smaller pieces—works identically when collaborating with AI, just as it does in human organizations.

Q. Why Is It Important to Request Work in Small Units in vibe coding?

Mason let out a deep sigh as he looked at his laptop monitor. The screen was tangled with incomplete code that the AI stopped writing halfway through, alongside numerous syntax errors.

“Sophia, look at this. I sent a prompt asking the AI, ‘Write the complete source code that implements user management, book search, note saving, and even a statistics dashboard feature for our reading app all at once.’ At first, it spewed out code excitedly, but then it cut off suddenly in the middle. When I told it ‘continue,’ it gave me random code with completely different variable names from the first part. Why is such a smart AI so sloppy?”

Sophia checked Mason’s prompt window and shook her head.

“Mason, you basically just told a new intern, ‘Before you leave today, draft our company’s new product plan, design it, write the marketing strategy, and prepare the financial statements all at once.’ What would happen to the intern’s brain? It would explode. AI is the exact same. No matter how fast its computing speed is, there are clear ‘technical limits’ to the context it can handle and the volume it can output at one time.”

Mason asked defensively, “Isn’t it more efficient for a computer to process everything at once?”

Daniel joined the conversation, approaching the whiteboard and writing “Chunking (Requesting in Small Units).”

“Even in the human world, if you try to finish a massive project all at once, you inevitably get burnt out and the boat goes off course. That’s why we managers break down work into ‘daily task’ units. The exact same rule applies when delegating to AI. Only when you make requests small do you get speed and eliminate errors.”

The Technique of Atomic Requests to Maximize Accuracy

There are three major technical reasons why throwing massive requirements at an AI (LLM) all at once is guaranteed to fail:

• The Wall of Max Output Tokens: AI models have strict limits on the number of characters (tokens) they can output in a single response. If you request a massive system’s code at once, it hits a physical limit mid-writing and abruptly cuts off.
• Context Degradation: If a request is too long and complex, the AI commits errors by forgetting constraints written at the beginning (e.g., “Use Tailwind for design”) and randomly pulling in plain CSS when writing later code.
• Impossibility of Debugging: If you receive and run code spanning 5 files all at once and an error occurs, it becomes nearly impossible to trace back where things went wrong. Conversely, if you receive and run just 1 function in 1 file, the cause of the error is clearly visible.

Sophia took Mason’s keyboard and deleted the complex, oversized prompt entirely. Then, she broke down the request to just one thing that needed to be implemented first—defining the data model—and typed it again in a tiny chunk.

[Request Prompt – Step 1]

We are going to build a reading note app. For now, do not build screens or complex features; we will set up only ‘a single reading note data structure.’

[Requirements]

Define an Interface named BookMemo using TypeScript.

Fields to include: id (string), bookTitle (string), content (string), createdAt (date).

Do not write any other code; cleanly output only this interface definition code.

The moment she hit enter, the AI outputted a clean, flawless interface code with zero room for errors in just a second.

“See? Step 1 is completely done. Now you copy the code into your file, and then you request Step 2.” Sophia continued typing the prompt.

[Request Prompt – Step 2]

Based on the BookMemo interface defined just now, write a simple addMemo function that adds 1 note to an array.

Exception Handling: If content is empty, it should not be added and must return an error.

The AI accurately produced only the addMemo function logic without any unnecessary bloat this time as well.

Only then did Mason slap his knee.

“Ah… instead of demanding a giant feature all at once, it’s about assembling components step-by-step like laying bricks one by one: ‘Define interface -> Implement add function -> Create screen UI.’ Doing it this way prevents code from cutting off mid-way, and even if an error occurs, I only need to look at the few lines just added, so I can fix it immediately.”

Daniel smiled and wrote the conclusion on the whiteboard.

“The real secret to gaining speed in vibe coding isn’t ‘ordering a lot at once,’ but ‘repeating small, error-free steps at ultra-high speed.’ The smaller humans break down instructions, the sharper the AI’s resolution becomes. Abandoning greed and breaking down work to match the AI’s stride—that is the real piloting skill of a veteran vibe coder.”

Mason opened his notebook and wrote down today’s guideline: “Contain only one feature (function/component) in a single prompt. Request the next brick only after verifying that the current one works perfectly.” Toward becoming a true architect who safely controls AI by breaking massive systems down, Mason took one step further.

Chapter 12 Summary

• If you request too large a feature from AI at once, the code cuts off mid-way due to the maximum output token limit, or the AI makes errors by forgetting prior constraints.
• For successful vibe coding, you must decompose (chunk) the entire system into sequential, “atomic” tasks that can be verified within a day or just a few hours.
• Developing in small units allows you to pinpoint the exact cause when an error occurs, making debugging speed overwhelmingly faster.