I Skipped the Design Phase Because I Knew the Topic. It Cost Me a Saturday.

I build training material in 6 steps: topic, research, structure, write, review, polish. On a topic I knew cold, I skipped steps 2 and 3 — research and structure — because I "already had it all in my head." That decision cost me a full Saturday and 3 rewrites of the same section.

TL;DR: the urge to skip prep doesn't scale with topic difficulty — it scales with your own confidence, which means the riskiest moment is exactly when you feel most ready.

What actually happened

That Saturday I sat down to write training material on a topic I'd taught for years. Coffee first, then straight into the draft — no notes, no outline. I felt fluent, so I skipped step 2 (gather concrete examples) and step 3 (decide the order a first-time reader needs them in).

About 30 minutes in, I reached for a concrete example and my hands stopped. The line under "here's an example" stayed blank. That was the first signal something was wrong — I had the topic in my head, but not in a form a reader could use.

I kept going anyway, filling in whatever I could write and skipping the parts that needed examples. By early afternoon I had a lot of text and a feeling of progress. Then I read the whole thing top to bottom.

The order was wrong. Not slightly wrong — completely wrong. I'd written it in the order I'd say it out loud: most interesting point first, background explanation pushed to the end. A first-time reader hitting paragraph 3 would run into a term I hadn't explained yet. I'd written my own internal map of the topic, not a path a stranger could walk.

I rewrote roughly the same section 3 times that day. Rewrite #1: stalled on missing examples. Rewrite #2: tried to fix the order, the whole thing fell apart structurally. Rewrite #3: finally held together. The coffee had gone cold hours earlier, and it was dark outside by the time I was done.

The number that changed my mind

I didn't track this with a stopwatch — this is a self-observed, single-incident measurement, not a controlled study. But the shape of the day was unambiguous enough to draw a real lesson from:

step	what I actually spent
research + structure (skipped)	~0 minutes
time to first stall	~30 minutes
rewrites of the same section	3
total time	full Saturday (morning coffee to dark outside)
estimated time if I'd spent 1h research + 30min structure first	roughly half the day

The step I skipped to save time became the most expensive part of the day — by a wide margin. Whatever confidence bought me in speed at minute zero, it charged back with interest by minute thirty.

Here's the same failure mode, restated as pseudocode, because I recognized it immediately once I'd lived through the writing version:

# what I actually did (skip design, write straight into implementation)
def build_feature(requirements):
    # "I know this codebase, I don't need to spec it out"
    code = write_implementation_directly(requirements)  # ~0 min spent on design
    # 30 min later: an edge case surfaces that the skipped design phase
    # would have caught — wrong assumption baked into the structure
    if not handles_edge_case(code, requirements):
        code = rewrite(code)   # rewrite #1
        if not handles_edge_case(code, requirements):
            code = rewrite(code)  # rewrite #2
    return code  # arrived at the right shape, 3 rewrites later

# what would have actually been faster
def build_feature_v2(requirements):
    spec = research(requirements)      # ~60 min
    structure = design(spec)           # ~30 min
    return write_implementation(structure)  # ~half the total time of the version above

Swap "training material" for "a familiar feature in a codebase I know well" and the trace is identical: skip the design phase because you're confident, hit a wrong assumption partway through, discard work, repeat until the structure holds.

The rule I extracted

The reflex to skip prep doesn't fire on hard topics — people already brace for those, slow down, take notes. It fires specifically on topics you're fluent in, because fluency feels like completion.

Knowing the material and having the reader's on-ramp for the material are two different assets. One is stored in your head. The other has to be actively built — and skipping that build is what "I already know this" quietly disguises.

The gap that bites you isn't "I don't understand this well enough." It's "the shape I'm holding in my head — the finished-feeling shape — is not the same object as the finished structure a stranger can follow." That gap is invisible from the inside, which is exactly why it only shows up once you're deep into rewrite number two.

Try it yourself

A trainee once described this to me, almost word for word what I'd told myself that Saturday morning: "isn't it faster to just think while writing?" I didn't lecture. I said "I lost a Saturday to that exact sentence last week."

Next time you're about to skip the design/outline step because "I know this one" — that's the tell, not a green light. What's the smallest thing you can research or outline before you let yourself write the first line?

---

Sho Naka (nomurasan). I build training material and ship code, and I write down what breaks when I get overconfident about either one.

This is an adapted English version of an essay I first wrote in Japanese. I worked with AI to shape and translate the piece; the incident, the numbers, and the conclusions are my own firsthand account.