Think. Don't Code.

Think. Don't Code.
How analytics professionals must use AI to solve problems they were never meant to handle alone.
by Carol Marmute
Connect on LinkedIn
A Note on How This Manifest Was Written
I co-wrote this manifest with AI. Not "AI helped me edit it." Not "AI suggested some ideas." I mean: I brought the thinking, the experience, the judgment, and the stories. AI brought the structure, the speed, and the drafts. We worked back and forth until the language said what I actually meant.
That's exactly what this Manifest is about. So if you're reading this and thinking "did a human write this?" — yes. And also: that's the wrong question. The better question is whether the thinking is real. Whether the experience behind it is real.
Some project details, figures, and specifics have been altered or generalized to protect confidential and strategic information. The methodology, frameworks, and process described are real.
Is writing code the best use of your time?
If you know how to code, you've felt the hours lost to syntax, debugging, formatting — hours that could have gone to solving the actual problem. If you don't, you've felt how certain analyses just stay out of reach.
I spent years living between the tech world and the business world — too analytical for the commercial side, too commercial for the data side. For a long time, I thought that was a problem to fix. It wasn't. It was the advantage I hadn't figured out how to use yet.
The people who can move between both worlds — who understand the model AND the decision it needs to drive — are the kind of people neither side can replace alone. That space is yours. This manifest is about how to use it.
What Actually Happened on the Project
A global consumer goods company had a supply chain optimization model running across 65 factories in 8 countries. At product level, across every trade route, it calculated duty rate differentials, lead time impacts, and cost deltas. The model was technically correct.
The output was operationally useless. It told the sourcing lead where demand should land. It didn't tell her how to get there — which factories to transition first, in what sequence, with what cost and duty rate exposure at each step. And the first model didn't signal that a second question existed. It delivered the optimal scenario and stopped. Seeing that the output was really the starting point for a harder problem — how to transition from the current state to that optimum with the minimum number of movements — took a human decision. No tool surfaces that question on its own. The model saw the destination. Nobody had built the path.
Here's what we built together:
Factory Flow Analysis
Mixed Integer Linear Program — minimize unmet volume and active connections, with a hard minimum of 10,000 units per movement.
Market Redirect
Same product, same factory — but which market should receive it? Solved for redirecting output to a different geography.
Output
Six tabs in Excel, six tables in Databricks, topped with a Pareto ranking flagging the top 80% of total gain as priority actions.
The Division That Actually Matters
Every line of Python that built this was written by AI. But here's what that actually means:
AI Wrote
The data pipeline
The MILP formulation and solver execution
The Pareto ranking algorithm
The Excel output and Databricks writes
I Built
The recognition that the transition problem was solvable with linear programming — and that it required an integer formulation to reflect real operational constraints.
The decision of what would be the MILP objective function
The 10,000-unit minimum threshold movement
The call to rank by profit opportunity, not volume, using Pareto
The decision to run two approaches/scenarios instead of one
What the sourcing lead needed to say to her director
An off-the-shelf AI Analyst couldn't have solved this. The optimal scenario already existed — the first model knew where demand should land. The real problem was building the path to get there: turning the current state into the target state while respecting operational limits and minimum movement sizes. That's a separate and harder problem than the first model solved. No off-the-shelf tool is going to infer that extra step for you.
Before AI, this same transition problem was solved using cumulative intervals built in Excel. The MILP didn't replace that thinking — it scaled it. The understanding of the problem was already there. AI handled the computational complexity. That's not a shortcut. That's what augmentation looks like in practice.
You are not competing with AI. You are deciding what to think about while AI handles everything else.
The Architect's Method 
What I used on this project wasn't luck or experience alone. It was a method that turns AI from a tool you type at into a system that helps you structure the work and move faster. Every analysis that matters follows this sequence:
01
Map the Room
Before any tool: who acts on this, what do they need, how do they think, what are the stakes?
02
Architect the Brief
Write the Director's Brief. Stage, Expert, Seat, Shape, Ask. This is where quality is decided — before AI writes a single line.
03
Iterate
Run it. Describe what's wrong precisely. Each iteration is not a correction — it is the method.
04
Stage the Logic
Ground Truth, Mechanism, Consequence, Decision. Make the reasoning visible. Make the decision unavoidable.
05
Stress Test
Find the holes before someone else does. Fix them. Ship something defensible.
STEP  1
Map the Room
Most people start with the data. The Architect's Method starts with a question: who is going to use this, and what do they need to be able to do with it? Answer these four questions before you build anything.
The Chair
Who acts on this output? A sourcing lead thinks in operational feasibility. A data scientist thinks in model assumptions. Design for the chair, not for yourself.
The Gap
What does this person need to DO after seeing your work? Build backwards from the decision your output needs to enable.
The Filter
How do they process information? Some need the business logic first. Some need three columns, not twelve. Deliver in their format.
The Stakes
What happens if they act on wrong information? High stakes means the reasoning needs to be visible and defensible — not just correct.
STEP 2
Architect the Brief
Most people talk to AI the way they'd message a new intern — short, context-free, assuming the other side fills in what's missing. The key skill in AI-assisted analytics is knowing how to describe a problem precisely enough that AI produces something useful on the first pass. I call it The Director's Brief.
The Stage
Full context: business situation, the problem, the data, the constraints.
The Expert
Cast the role with precision — not "data analyst" but a specific senior expert with relevant domain experience.
The Seat
Name the audience. A sourcing lead and a VP of Operations are not the same audience.
The Shape
The exact format: a Python script? A ranked table? A decision memo?
The Ask
The precise deliverable — not "analyze this" but a specific script, output, and rationale per move.
Describing a problem well is not a soft skill. It is the analytical skill of this decade.
STEP 3
The Iteration with AI
The first AI output won't be perfect. That's not a failure — it's the process. Run it. See what breaks. Describe what's wrong and why. Each iteration makes the problem clearer and the answer more usable.
"The duty rate calculation is routing Factory A through the wrong port — reroute through Port Y. Also, moves 4 and 5 have a dependency: Factory B can't start until Factory A completes 60% of its reallocation. Add that constraint and rerank."
You are not debugging code. You are refining your understanding of the business — and letting AI keep up with you.
Step 4
Stage the Logic
A correct output that nobody can defend is a useless output. When the leader presents Move 1 and the director asks "why this one first?" — she needs a real answer. Not "the model said so." Staging the Logic means building your analysis in four visible layers.
Ground Truth
What the data actually shows. No interpretation. The baseline everyone agrees on before the analysis begins.
Mechanism
Why this move makes sense — the cost structure, the duty rate differential, the constraint that makes this the right sequence. Where most analyses stop too early.
Consequence
What happens if we act, and what if we don't. Concrete and specific: "each quarter of delay is a quarter of carrying 18% duty rate on already-contracted volumes."
Decision
One clear action. Not options. Not a recommendation with caveats. The single thing this person needs to do next.
Ground Truth: Factory A carries 18% duty on volumes routed through Port X.
Mechanism: Rerouting through Port Y reduces that to 6% — but only if the transition starts before Q3 contracted volumes are locked.
Consequence: Each quarter of delay is a quarter of carrying 12 percentage points of unnecessary duty on already-committed volumes.
Decision: Start Factory A transition in week 1. 
STEP 5
The Stress Test
The ranking is built. The logic is staged. One final step: ask AI to attack it — not to validate, to find what doesn't hold up before the person in the room does. This is the move most people skip. It's also the one that saves you most often.
"Act as the most skeptical person in the room. You are not helping me improve this. You are trying to find what doesn't hold up. Give me the four hardest questions this person will ask, and for each one: what a strong answer looks like, and what a weak answer sounds like."
Here's what that looks like in practice.
The weak answer defers to the model. The strong answer shows you understand what the model can't see. That's what the Stress Test is built to reveal.
How AI Actually Works With You 
You've just run the full method. You mapped the room, architected the brief, iterated, staged the logic, and stress-tested the output. Across all five steps, you moved between three different modes of working with AI. Most people never name them. That's why they get stuck.
Automation
AI follows explicit instructions and does the work. The Director's Brief (as described in Step 2) in action: you describe precisely, AI executes. The Python pipeline, MILP formulations, Excel output — all automation.
Augmentation
You and AI build together. Upload. Run. Break. Debug. Refine. The output gets more precise with every exchange — until what comes out is something that can run in production.
Agency
AI works independently on your behalf. Once the pipeline was validated, it ran in Databricks without me — writing to Delta tables while I moved on to the next problem.
Knowing which mode you're in — and when to switch — is the skill beneath the skill.
For ALL Seniority
Creation Diligence
On the supply chain project, there was no review layer. A group of consultants, AI-assisted, producing outputs that fed directly into a board-level recommendation. Creation Diligence is what you put in place when the review layer is you.
Before you sign off on any AI-assisted workflow, you should be able to answer three questions. Not in a framework. In a room.
Can you explain it without the model?
If the only person who can defend the output is the AI or the model that produced it, you don't have an analysis. You have a black box with a deadline. The analyst should be able to walk through the logic — the assumptions, the constraints and the judgment calls.
Do you know where it could be wrong?
Not where it's probably wrong. Where it could be. Every AI-assisted output has a failure mode — a constraint it didn't see, a dependency it couldn't model, a stakeholder assumption baked in from the brief. If you can't name it, you haven't stress-tested it.
Who owns the decision?
AI can rank, sequence, and structure. It cannot be accountable. Someone in the room has to own the call — and that person needs to have done enough thinking to deserve that ownership. Speed is not an excuse for skipping this.
Creation Diligence isn't a checklist. It's the standard you hold yourself to when the model moves faster than the organization can review.
The method cannot do this for you:
It cannot know what leaders need to say to their director.
It cannot judge which transitions are politically sensitive this quarter.
It cannot decide that operational feasibility matters more than theoretical optimality.
It cannot tell when the data is technically right but operationally wrong.
AI handles the execution. You handle what matters. Think. Don't code.
— Carol Marmute
She writes about AI, analytics, and how to think better with both.
linkedin.com/in/carolinnemarmute
Written with AI. Thought without it. — 2026