Stop Prompting — Start Planning

Prompt Engineering Is the Wrong Tool for Serious Work

For any AI project larger than a single-file change, an implementation plan outperforms prompt engineering by an order of magnitude. AI project planning is the discipline that delivers: the plan is where the thinking happens — the prompts are just how you click "go." If you're spending your time crafting the perfect AI prompt, you're optimizing the wrong layer.

What is AI project planning? AI project planning is the practice of writing a detailed implementation document — describing what you're building, how it works, what could go wrong, and how you'll verify it — before giving an AI any execution instructions. The plan replaces prompt engineering for complex, multi-file work: instead of crafting better prompts, you craft a better plan. The prompts become single-line references to plan sections.

Prompt engineering works when you need a single output: a function, a component, a paragraph. Ask the right way, get the right thing. Fine.

But the moment your project involves multiple files, interdependent systems, design decisions that cascade, or features that need to work together — prompt engineering collapses. You can't prompt your way through a complex feature. You need a plan.

We built every major feature on this site — fleeing cards, the AI companion, the hidden puzzle, the admin dashboard — not with clever prompts, but with implementation plans we spent hours writing and refining before a single line of code was generated.

What an Implementation Plan Actually Looks Like

AI project planning starts with a structured document that describes:

This isn't a specification document. It's a thinking document. The act of writing the plan forces you to think through decisions you'd otherwise discover mid-implementation — when fixing them is 10x harder.

Here's what a real plan section looks like from this site's development:

Smart Scheduler: The admin dashboard needs a scheduling feature that auto-publishes draft posts at 2/day. Posts should get random hours between 6AM-8PM to look organic. The scheduler must check existing scheduled dates to avoid slot conflicts. Published posts with future scheduledDates should be hidden from the public blog — handled server-side by filtering in getAllPosts(). No cron jobs needed.

That paragraph contains 6 design decisions. Writing it took 5 minutes. Discovering those 6 decisions through trial-and-error prompting would have taken an hour and produced 6 bugs.

The 3-Hour Plan That Builds in 20 Minutes

The pattern looks like this: you spend 3 hours on the plan. Then you tell the AI "build section 1" and it's done in 5 minutes. "Build section 2." Done. "Build section 3." Done.

The implementation is fast because the decisions are already made. The AI isn't guessing what you want. It isn't interpreting ambiguous instructions. It's executing a plan that you've already thought through.

Compare this to the prompt engineering approach:

You're spending the same 3 hours — but spending them debugging outputs instead of thinking clearly.

The Task List Is Your Best Tool

The most underrated AI collaboration technique is the humble task list. Not a backlog. Not a Jira board. A markdown checklist.

## Blog Admin Dashboard
- [x] Add scheduledDate field to Post interface
- [x] Create getAllPostsAdmin() for fetching all posts
- [x] Build API route for individual post editing
- [x] Build smart scheduler with slot conflict checking
- [ ] Add thumbnail upload with auto-compression
- [ ] Add content body editor

Here's why this works:

It gives you a place to iterate. You write the first draft of the list. You stare at it. You rearrange items. You realize item 4 depends on something you forgot. You add it. You notice two items can be merged. You sleep on it.

This is the planning that prompt engineering skips entirely. You can "sleep on a prompt." You can sleep on a task list.

It gives the AI context. When you share this list with an AI and say "build the next unchecked item," the AI understands:

• What's already been built (checked items)
• What's coming next (unchecked items)
• How this piece fits into the larger system

It gives you momentum. Checking off items is addictive. The list shows progress. It shows what's left. It prevents the "what do I work on next" paralysis that kills complex projects.

Cooking Time Is Engineering Time

Sometimes you need to let an idea sit. We call this "cooking."

The blog card fleeing system didn't arrive fully formed. The idea of "cards that run from your cursor" came first. Then it sat in a notes document for two days. During those two days, without actively working on it, the idea evolved:

• Day 1 afternoon: What if they leave behind a ghost when they flee?
• Day 2 morning: What if each card has a personality that changes the flee behavior?
• Day 2 evening: What if two cards could argue with each other about who fled first?

None of these ideas came from prompting. They came from not prompting — from walking around with the idea in your head and letting it connect with other ideas organically.

Prompt engineering culture is obsessed with speed. Write the prompt, get the output, ship it. But the best features come from slow thinking followed by fast execution. Spend the time cooking. The AI will still be there when you're ready.

The Plan Evolves — That's the Point

A common objection: "But what if the plan is wrong?"

Plans are always wrong. That's the point. They're wrong in ways you can see and fix before you've written code.

Here's how AI project planning evolves in practice:

The plan changes during execution too. You discover that section 3 needs a different approach. You update the plan. You adjust the remaining checklist. This is normal. This is engineering.

The difference is that you're changing a plan — not rewriting prompts from scratch because the AI produced something unexpected.

Why This Works With Modern AI

Modern AI coding assistants — working inside IDE environments with full project context — are exceptionally good at executing well-defined sections of work. They can read your existing files, understand your types, follow your patterns.

What they can't do is make your design decisions for you. They can't decide whether your scheduler should use cron jobs or request-time filtering. They can't decide whether your blog cards should flee smoothly or teleport. They can't decide whether your color scheme is too generic for your brand.

Those decisions belong in the plan. Once they're made, the AI executes them flawlessly.

Does implementation planning slow things down? No — it speeds them up. The 3 hours spent on a solid plan almost always recover themselves in the first implementation session: fewer revision loops, fewer discovered edge cases mid-build, fewer instances of the AI generating something coherent but wrong. Total time from idea to shipped feature is consistently shorter with a plan than without one.

The division of labor:

The prompt was never the lever. The plan is. Stop prompting better — start planning clearer. That's the whole upgrade, and it compounds: every hour you put into a plan saves two in execution and three in debugging.

→ Clearer Vision, Not Better Prompts — the companion piece on why clarity of vision is the upstream constraint on everything the plan solves.

This post is part of our AI Productivity Stack — the full system for building faster, thinking clearer, and shipping better with AI.