I made the app plan the whole module before it wrote a single step
Steps built one at a time all sounded alike. Planning around the stack first fixed it.
Learn · Oct 30, 2026
Two people picked different tools for the same module in The Automated CMO. The steps they got back read almost the same.
That bothered me. The whole point of the app is that your plan fits your stack. If the stack changes and the plan doesn't, it's a template with a nice coat of paint.
So I stopped patching the wording and looked at how the steps were being built. The problem wasn't the prompt. It was the order of operations.
Here's what I changed, what I checked before trusting it, and the habit I'm keeping from it. It took one afternoon of looking, and far less code than I expected.
Find out why the steps all sounded alike
Each step was personalized on its own, one at a time, when the page loaded. That sounds fine until you think about what each call could see. Nothing. Step three had no idea what step two said. Step five didn't know which tool had already been given the heavy lifting. So every step did its best with the same small amount of context. The result was steps that were individually reasonable and collectively generic. I'd been treating it like a wording problem. It was a structure problem. No amount of prompt polish fixes a call that can't see the rest of the module.
Plan the whole module when the stack is saved
The fix was to move the thinking earlier. When someone saves their stack, the app now plans the entire module in one pass. Each tool gets a job. The setup it needs gets named. What gets shared between tools gets decided once, in one place. Then the steps get written from that plan. Plan first, write second. It's the same instinct I keep coming back to on this project: make the decision once, where everything is visible, instead of making many small guesses where nothing is.
Try it on one module before touching the rest
I didn't turn this on everywhere. I built it for a single module, Customer Persona Generator, and looked at it on a preview deploy first. That module was a good test because the stack changes the answer so much. Different tools mean different jobs, different setup, different handoffs. If the plan-then-write flow was going to prove itself, it would show up there. It did. On preview, the steps finally read like they knew about each other.
Keep the risky parts behind a flag
The same habit showed up on the Riskiest Page Builder. This week's piece there was a live sandbox preview, the level 8 feature on that build. I deployed it to production with the flag turned off. The code is live. Nobody sees it yet. That split matters more than it sounds. Deploying and releasing are two different decisions. When they're separate, a deploy is boring, and boring is what I want from a deploy. I get to look at the thing in its real home before anyone depends on it.
Remove the gate and ship it to every module
Because the preview held up, the next commit was mostly deletion. I took out the single-module gate from the stack, step, building and API paths, so every published module uses the planned flow. The copy changed too. Instead of a generic line, the app now says the step uses your specific tool's MCP server, by name. Small thing. But a reader who sees their own tool named trusts the page more than one who sees a placeholder. Same day, I also activated 14 of the 15 prioritized agent candidates as working agents, with their prompts pulled straight from the companion skill files instead of rewritten by hand.
What broke: Nothing crashed. That's what made it easy to miss. Every step on the page was fine on its own, and the module as a whole said very little about the person's actual stack. Each step was personalized separately on page load, so no step knew what the others said. Two different stacks produced modules that looked much the same.
The fix: Plan the whole module when the stack is saved, then write the steps from that plan. I tested it on one module on a preview deploy before removing the gate for all of them. Here's the thing: the better prompt was never going to work. The call needed to see the whole picture first. That's the part I'd tell anyone building with AI. When output feels generic, don't reach for sharper wording yet. Ask what the model could actually see when it answered. Sometimes the fix is giving it more to look at, earlier. Next I want to see how the plan holds up for stacks I haven't tried.
You're building a feature that generates a multi-step guide personalized to a user's tech stack.
Right now each step is generated on its own, so the steps don't know about each other and every guide ends up generic.
Change it to two stages:
1. PLAN. When the user saves their stack, make one call that returns a plan for the whole guide: the job each tool does, the setup each tool needs, and anything shared between tools. Return it as structured JSON and store it.
2. WRITE. Generate each step from that stored plan, not from the stack alone. Every step must reference the plan.
Rules:
- Enable it for one guide first and show me the result before removing any feature gate.
- Use the user's real tool names in the copy. No placeholders.
- Don't invent commands or setup details. If the plan doesn't have it, leave it out.
Before you write code, list the files you'll change and the one thing most likely to break.Go deeper
I made the setup steps a lookup so a model can't invent a command →
Building the tool setup engine for the Riskiest Page Builder, and checking every block against vendor docs.
I Let the Model Write the Page Spec, Then Built Everything Around Its Mistakes →
Adding Claude to the Riskiest Page Builder meant writing the guardrails first: a kill switch, quotas, strict validation, and a renderer that only draws plain text.
Get new guides and builds in your inbox
No noise. New artifacts, skills, and lessons when they drop — and early access when agents launch.
Want a full structured path instead of one-off guides?
That's Learn AI with AI — a sequenced course that takes you from zero to building real things, with community and accountability built in.
Check out Learn AI with AI →