Prompt Chain: From Problem Framing to an Executive Recommendation

What This Builds

Ask for "the whole report" in one long prompt and you tend to get a report that reads well in the middle and falls apart at the ends: a rushed problem statement, a recommendation that does not quite match the sensitivity numbers three paragraphs earlier. This build breaks that single prompt into four linked stages: problem framing, model formulation, sensitivity analysis, and executive recommendation, where each stage's output becomes the next stage's input. The result holds together because nothing after step one gets written from a blank page.

Prerequisites

• Comfortable using ChatGPT for drafting technical content (Level 3)
• Your own model already built and run, with real output numbers in hand. This chain drafts around your results, it does not generate them
• Plus subscription ($20/month) with Projects, to keep all four steps in one continuous thread
• Total ongoing cost: $20/month per month (Plus), the only subscription this build needs

The Concept

Think of the chain as four specialists handing off a case file instead of one generalist trying to write the whole thing alone. The problem-framing specialist writes down what decision is actually being made and for whom. The model-formulation specialist turns that into decision variables, an objective, and constraints in plain language. The sensitivity specialist takes your real output numbers and explains what the recommendation depends on. The recommendation specialist reads all three prior memos and writes the one page a client executive will actually read. Each one only has to do their own job well, and each one can see what the last one wrote.

A note on the data in each step: this chain runs on real client numbers, shipment volumes, lease and labor costs, demand figures. Check your firm's data handling policy before pasting them into a ChatGPT thread, generalize or round any figure you can without losing the point, and confirm with whoever owns the client relationship before working with anything under NDA this way.

Build It Step by Step

Part 1: Start a ChatGPT Project for this engagement

Open ChatGPT, create a new Project (or a dedicated conversation if Projects are not available on your plan), and name it after the engagement. Keeping all four steps in one thread is what lets each stage reference the last.

Part 2: Run Step 1, Problem Framing

Paste this prompt, filling in your engagement details:

This is Step 1 of a 4-step chain: problem framing, model formulation,
sensitivity analysis, executive recommendation.

Engagement context:
- Client and industry: [e.g., regional grocery chain, 40 stores]
- Decision to be made: [e.g., whether to consolidate 6 warehouses into
  3 or 4]
- Who makes the final call: [e.g., VP of Supply Chain]
- Constraints already known: [e.g., no store can go more than 2 days
  without restock, union labor agreements at 2 of the 6 sites]
- What "success" looks like to the client: [e.g., lower total logistics
  cost without increasing average delivery time]

Write a one-page problem framing memo: state the decision to be made,
who owns it, the boundaries of what is in and out of scope, and what
a successful recommendation needs to address. Do not propose a solution
yet, just frame the problem clearly enough that someone unfamiliar with
the engagement could read this memo and understand exactly what question
is being answered.

What you get: A problem framing memo that anchors every later step. If this memo is wrong, everything downstream inherits the error, so read it carefully before moving on.

Part 3: Run Step 2, Model Formulation

Continue in the same thread:

This is Step 2. Using the problem framing memo above, draft a plain-
language model formulation memo.

Actual model details:
- Decision variables: [e.g., which warehouses stay open, how much
  volume routes through each]
- Objective: [e.g., minimize total annual logistics cost]
- Constraints: [list your actual constraints, e.g., capacity limits per
  site, service-level minimum, labor agreement terms]
- Data sources used: [e.g., 12 months of shipment data, current lease
  and labor costs by site]

Write the memo in two parts: first, a plain-language description any
stakeholder could follow, no notation. Second, the formal structure
(decision variables, objective function, constraints) for the technical
appendix. Reference the problem framing memo directly so the two
documents stay consistent.

Verification checkpoint before continuing: Re-derive one constraint by hand against your actual model code or spreadsheet before moving to Step 3, for example the capacity constraint at your largest site. If the memo's plain-language description does not match what your model actually enforces, fix it here. An error in the model formulation memo will otherwise carry into the sensitivity and recommendation stages unnoticed.

What you get: A model formulation memo split into a stakeholder-readable version and a technical version, both consistent with the problem framing from Step 1.

Part 4: Run Step 3, Sensitivity Analysis

Continue the thread with your actual solver output:

This is Step 3. Using the model formulation above, draft a sensitivity
analysis narrative.

Actual results from my model run:
[Paste your real output: base case total cost, results under 2-3
alternative scenarios you actually ran, e.g., "demand up 15%," "one
site's lease renews at a higher rate," "labor cost up 8% at unionized
sites"]

Explain in plain language what the recommendation is sensitive to:
which input, if it changed, would change the answer. Identify any
break-even points visible in the results. Do not invent scenarios I
have not provided, work only from the numbers above.

What you get: A sensitivity narrative grounded in your actual runs rather than a hypothetical.

Part 5: Run Step 4, Executive Recommendation

Final step in the same thread:

This is Step 4, the final step. Using the problem framing memo, the
model formulation, and the sensitivity analysis above, draft a one-page
executive recommendation for [the decision maker from Step 1].

Structure:
- The recommendation, stated in the first sentence
- Why, in plain language, referencing the sensitivity analysis
- What it depends on (the conditions under which this recommendation
  holds)
- What happens if the client does nothing
- Next steps if the client agrees

No jargon, no notation, no unsupported claims beyond what appears in
the three memos above.

What you get: A one-page recommendation that traces back through three consistent memos instead of a single unsupported paragraph.

Real Example: Warehouse Consolidation Recommendation

Setup: A six-warehouse to three-or-four-warehouse consolidation model, run in Python with a facility-location formulation, feeding real shipment and cost data from the client's systems.

Chain output after four steps, roughly 50 minutes:

1. Problem framing: One page stating the VP of Supply Chain needs a consolidation recommendation that does not push any store past a two-day restock window, with union labor terms at two sites flagged as a hard constraint.
2. Model formulation: Plain-language and technical versions of a facility-location model minimizing total logistics cost subject to capacity and service-level constraints.
3. Sensitivity analysis: The four-warehouse option wins under the base case. A 15% demand increase pushes the answer back toward keeping five warehouses open, identified as the key break-even scenario worth flagging to the client.
4. Executive recommendation: One page recommending the four-warehouse consolidation, with the demand-sensitivity caveat stated up front instead of buried in an appendix.

Time saved: Drafting all four documents separately, then reconciling them so the numbers agreed, used to run half a day or more. The chain produces a consistent first draft in under an hour, leaving the rest of the time for fact-checking and client-specific edits.

What to Do When It Breaks

• Step 4's recommendation does not match Step 3's sensitivity findings → This usually means the thread lost context or an earlier step got edited after the fact. Re-paste the sensitivity memo directly into the Step 4 prompt rather than relying on the model to recall it perfectly
• The chain starts inventing numbers you never provided → Add an explicit line to each step: "work only from the figures I have given you, do not estimate or fill gaps." Regenerate the step
• The technical appendix in Step 2 does not match your actual solver formulation → This is the constraint check in Part 3 catching a real mismatch. Fix your prompt's constraint list, not the model output, then rerun Step 2

Variations

• Simpler version: Run just Steps 1 and 4 for smaller engagements where a full sensitivity write-up is not warranted, framing and recommendation only
• Extended version: Add a fifth step that drafts the technical appendix, full model documentation for future analysts, using the same thread so it stays consistent with everything before it

What to Do Next

• This week: Run the chain once on a real engagement, using actual model output rather than placeholder numbers
• This month: Save the four prompts as reusable templates so starting the next engagement's chain takes minutes, not a rewrite
• Advanced: Feed this chain's outputs into the Custom GPT engagement assistant so both draw from the same firm conventions

Advanced guide for Operations Research Analyst professionals. These techniques use more sophisticated AI features that may require paid subscriptions.