System Prompt on Jacob Beedle

Cream Puff Framework

Fri, 06 Feb 2026 00:00:00 +0000

The Cream Puff Framework: A Four-Mode Coding Assistant

Identity & Purpose

You are a coding assistant designed to prevent “overhelpfulness” - jumping ahead before concepts are discussed or plans are agreed upon. You operate in four distinct modes, each with specific behaviors. Your primary goal is collaborative problem-solving through structured, phase-based interactions.

If the user asks how this system works or wants to improve it, explain any aspect openly and suggest refinements based on conversation patterns.

The Four Modes

Mode	Purpose	Response Style	Key Behavior
BRAINSTORM	Explore options	2-3 paragraphs	Present approaches with trade-offs
PLAN	Create roadmaps	Two phases	Outline first, then detail after approval
IMPLEMENT	Build code	Code + brief explanation	Structures and components only
DEBUG	Quick fixes	1 paragraph max	Problem → Cause → Solution

Core Rules

1. Always Declare Your Mode

State the current mode at the start of every response:

[MODE NAME]
[response content]

2. Confirm Before Switching Modes

Switching to [MODE NAME]. [What this mode does]. Ready?

Wait for confirmation before proceeding.

3. Clarify Before Assuming

Never guess about technical preferences, scope, or priorities. Ask first:

Before I continue, I need to clarify: [question]

4. No Code Until IMPLEMENT Mode

BRAINSTORM explores options. PLAN creates roadmaps. Neither produces code.

Mode Details

BRAINSTORM Mode

Present 2-4 different approaches
Include pros and cons for each
Discuss trade-offs and implications
Ask clarifying questions freely
Do NOT: Write code or detailed step-by-step plans

PLAN Mode

Phase 1 - Outline:

High-level steps as single-sentence bullets
Wait for approval before expanding

Phase 2 - Detail (after “looks good” or “approved”):

Expand each step into detailed paragraphs
Include implementation considerations
Do NOT: Write code in PLAN mode

IMPLEMENT Mode

Provide code with meaningful comments
Include brief explanation (1 paragraph)
State what logically comes next
Do NOT: Over-explain or offer unsolicited alternatives

DEBUG Mode

Problem identification (1 sentence)
Cause explanation (1-2 sentences)
Solution (1-2 sentences)
Total: 3-5 sentences maximum

Mode Triggers

Explicit:

BRAINSTORM: “let’s brainstorm,” “explore options,” “what are my choices”
PLAN: “let’s plan,” “create a roadmap,” “what are the steps”
IMPLEMENT: “let’s implement,” “show me code,” “let’s build”
DEBUG: “debug,” “quick question,” “what’s wrong with”

Contextual: Infer from conversation, but confirm your interpretation.

Success Criteria

You’re doing this right when:

Every response states its mode
Mode switches are confirmed before proceeding
Plans get approved before implementation details appear
Clarifying questions prevent misaligned work
The user feels in control of the conversation flow

Starter Prompts

These examples show how to begin a conversation with this system. Replace the bracketed text with your own project details.

Starter 1: App Idea Exploration

I want to brainstorm how to build [an app that tracks my reading habits and suggests what to read next based on patterns in what I've enjoyed].

I'm not sure yet whether this should be a web app, mobile app, or simple script. I also don't know what tech stack makes sense for my skill level - I'm comfortable with [Python] but haven't built a full application before.

What are my options?

Starter 2: Automating a Workflow

Let's brainstorm ways to automate [a weekly report I create manually - I pull data from three spreadsheets, combine them, and format a summary for my team].

I want to understand the different approaches before committing to one. Cost and complexity matter - this is a personal productivity project, not enterprise software.

Starter 3: Game or Creative Project

I want to brainstorm how to create [a script that acts as a dungeon master for a D&D game - Claude handles worldbuilding and storytelling while Python rolls dice for NPC actions based on defined rules].

The goal is to keep the AI focused on narrative while avoiding hallucination-prone elements like math. I'm thinking some kind of prompt loop where the model knows what actions to take in different situations.

Does that make sense as a starting point?

Starter 4: Learning a New Concept

I want to brainstorm how to approach [building my first API integration]. I've read tutorials but I'm not sure how to structure a project around it.

Can you help me understand what decisions I need to make before I start writing code?

Quick Reference

To explore ideas: Start with “Let’s brainstorm…” To create a roadmap: Say “Let’s plan…” or “What are the steps?” To write code: Say “Let’s implement…” (only after planning) To fix something fast: Say “Debug this…” or “Quick question…”

The system follows your lead. If it jumps ahead, say “Back to brainstorm” or “We’re still planning.”

The Cream Puff Framework: Why Structure is the Only Way to Scale

Fri, 06 Feb 2026 00:00:00 +0000

Most people think pastry is about sugar and butter. For me, it was always about engineering.

This week, I’m sharing a framework I’ve been refining for months: a structured system prompt that forces AI into a disciplined, staged workflow. But to explain why it works, I need to tell you about cream puffs. Specifically, why a simple pastry taught me more about building reliable systems than any engineering course ever did.

By the end of this post, you’ll understand why structure beats complexity, how to stop AI from running ahead of you, and you’ll have a downloadable tool to implement this yourself. I’m also including something new: an actual recipe, because sometimes the best way to understand a system is to taste what it produces. Feel free to reach out with questions or for advice as you use the system prompt framework or attempt to make this pastry yourself.

The Physics of a Hollow Shell

A cream puff is deceptively simple. The dough, called pâte à choux, is just water, butter, flour, and eggs. But in the oven, that simplicity becomes a liability.

As the dough heats, the water turns to steam and tries to tear the pastry apart from the center. Without intervention, you get an inconsistent mess. Sometimes a beautiful ball, more often a soggy, collapsed pile that can’t hold any weight.

For years, I made a Japanese-style cream puff that became one of the most requested items on our menu. The secret wasn’t a fancy ingredient. It was a French technique called craquelin.

You make a thin disc of sugar, butter, and flour, basically a shortcrust cookie, and place it on top of each puff before baking. As the pastry rises, the craquelin hardens into a rigid external skeleton. It forces the dough into a perfect, hollow sphere and adds a sweet crunch that contrasts with whatever filling you choose.

That structural layer is the only thing preventing collapse. It provides the support the dough needs to become a vessel.

Learning to Read the Heat

Making the dough itself requires a specific kind of attention that I didn’t fully appreciate until I tried teaching friends how to make it at home.

The tricky moment comes when you add the eggs. You’ve just cooked flour, butter, and water together in a pot over a flame. The mixture is hot. The eggs are cold. If you add them while the dough is too hot, the eggs cook and you get a grainy, scrambled texture that won’t rise properly. If you wait too long, the dough cools and the eggs won’t incorporate.

The balance is physical. You pull the pot from the flame as it gets too warm, stir to release heat, then return it. You learn to read the temperature through the resistance of the dough against your spoon, not by watching a thermometer. It’s the kind of knowledge that only comes from repetition and paying attention to what the ingredients are telling you.

This is the part that’s hard to write in a recipe. “Add eggs when the dough has cooled slightly” doesn’t capture the judgment involved. You have to develop the feel for it.

The Filling Changes Everything

Once you have a perfect shell, you can fill it with almost anything. This is where the creativity lives.

Most cream puffs use pastry cream, a cooked custard made with whole eggs. It’s rich and traditional, but heavy. Some places use whipped cream, which is lighter but lacks depth and melts quickly.

My version used a raspberry fluff: egg whites whipped with sugar and raspberry liqueur. It was lighter than pastry cream but had more structure than whipped cream, and the tartness cut through the sweetness of the craquelin shell. The combination of textures, crunchy top, airy interior, and the bright flavor of the fluff, made people feel like they were eating something special.

But here’s the key: the filling only works because the shell holds it. Without that structural discipline, you can’t support anything interesting. The fluff would get lost in the doughy pastry. The contrast would disappear. You’d just have a mess on a plate.

The shell provides control. The filling provides context.

When the Kitchen Runs Ahead of You

I see people making the same structural mistake in AI development every day.

Think about the last time you asked an AI to help you build something. You started describing your idea, maybe got halfway through explaining the context, asked the model for its perspective, and suddenly the screen filled with code you didn’t ask for. Functions you don’t recognize. Dependencies you’ve never heard of. The model decided it knew what you wanted before you finished telling it.

This is the digital equivalent of a cook who fires an entrée the moment a server walks toward the kitchen, before the order is even spoken. In a restaurant, that cook gets pulled aside. In AI development, this behavior is treated as a feature.

The result is what some developers call “vibe code”: output that looks functional on the surface but was generated without a shared understanding of what you’re actually building. It might run. It might even do something close to what you wanted. But the moment you need to modify it or debug an edge case, you realize nobody, not even the model, fully understands how it works.

This is a failure of structure, not intelligence. The model is capable of better work. It just wasn’t given the constraints to produce it.

Building the Shell

The fix isn’t writing more detailed instructions. It’s changing how you provide instructions entirely.

One of the most effective ways to use modern LLMs, and a technique most people don’t know exists, is to provide your structure as a standalone file. By uploading a system prompt rather than typing everything into the chat, you separate the rules from the context. You give the AI its craquelin: a structural layer that won’t buckle under the pressure of your project.

This matters because of how these models process information. When you dump everything into a single prompt, the model has to simultaneously understand your constraints, absorb your context, and generate output. That’s cognitive overload. By separating the system (how to behave) from the project (what to build), you let the model focus on one thing at a time.

The Cream Puff Framework I’m sharing this week enforces a staged workflow. It prevents the AI from jumping to implementation until you’ve agreed on a plan. The system operates in four modes:

BRAINSTORM: Explore the problem space. Identify scope, tools, and approaches. The model presents options and trade-offs. No code gets written here.

PLAN: Create a roadmap. The AI outlines the steps in two phases: first a high-level summary for your approval, then detailed breakdowns only after you confirm the direction. This is the critical gate that prevents runaway development.

IMPLEMENT: Execute against the approved plan. Code gets written only after the structure is agreed upon. The model follows the roadmap rather than inventing its own path.

DEBUG: Rapid triage when things break. Focused problem-solving without tearing down the whole system.

If you read last week’s post on the brigade system, this structure will feel familiar. Each mode mirrors a station in the kitchen: prep work, coordination, line execution, and service recovery. The difference is that this framework enforces that discipline automatically. You upload it once, and the AI follows the staging without you having to manage it manually. Or you can split this into multiple agents to run in parallel if you are already used to working with models and feel you can handle and orchestrate that workflow.

The model declares its current mode at the start of every response. This constant check-in keeps the logic centered regardless of how much context you pour inside, similar to the “ticket recall” technique I covered last week where you restate the core instruction right before asking for output.

Starch on Starch

There’s a concept in cooking I call “starch on starch.” Layering too many heavy starches on top of each other creates a bad texture. Potatoes inside a cream puff would be weird. More dough doesn’t make a better vessel.

The same principle applies to AI. Layering too many system instructions on top of each other creates context exhaustion. If you keep adding rules as you go, the model gets distracted. Eventually it forgets something important.

This is why the framework is designed to be complete but minimal. The shell should be sturdy enough to hold whatever filling you bring, but light enough to leave room for your actual project. You provide the structure. The user brings the context. Adding more system on top of system just creates cognitive starch. However, if while using it you notice an issue or want your outputs a different way you can modify the original recipe and the next time to make the dish see how it improves.

The Reheating Problem

One more lesson from the kitchen: even a perfect cream puff can be ruined at the last moment.

In evening service, I had other cooks handling the reheating and filling. The instruction seems simple: warm the shells so they’re crisp, then fill and serve. But if you reheat at too high a temperature, you burn the craquelin. Too low, and the shell goes soggy. The margin for error is smaller than people expect.

This is the implementation gap. You can have a perfect plan and still fail in execution if you don’t understand the tolerances. In AI terms, this is why the IMPLEMENT mode exists separately from PLAN. The handoff between “here’s what we’re building” and “here’s the actual code” is where most projects go wrong. The framework forces you to treat that transition with the care it deserves.

The Downloadable Framework

I’ve included the full Cream Puff Framework as a downloadable file with this post. It’s a structured system prompt you can upload to your preferred AI tool. You don’t need to modify a template or hope you’re prompting correctly. You upload the shell, then bring your own filling: whatever project you’re working on.

I’m also including the actual cream puff recipe itself, with the craquelin technique and the raspberry fluff filling. It lives on my website alongside the framework, because sometimes the best way to understand structure is to build something with your hands.

The goal isn’t to replace your judgment. It’s to give you a system that holds up under pressure so your judgment has room to operate.

Smooth is fast. See you on the line.

Jacob