What Yale MBAs Don't Know About AI Prompting (But Should)

At my Yale SOM reunion last week, the conversation inevitably turned to AI and how it's impacting our work. Over beers, I was fascinated by the spectrum of experiences.

One friend half-joked about "stacking as much money as possible" before AGI hits, sharing how ChatGPT Deep Research effectively drove their e-commerce startup's product launch strategy.

Meanwhile, another classmate was dismissive, stating these tools "often make stuff up" and couldn't be trusted.

"Have you tried turning on the Web Search tool?" I asked.

"The what?"

"And explicitly telling it to return only respectable sources?"

"No, shouldn't it already know to do that?"

This exchange highlights a common theme: the wide gap in results often stems not from which model is used, but how users structure their interactions.

Many approach AI with a search engine mentality; type a short query, filter for the best result in the query. However, these systems are fundamentally different; they respond dramatically better to structured, even conversational guidance.

Bare-minimum prompts leave the model to fill too many gaps. The foundation is crucial.

So before your next AI interaction, here's what might help.

15-Second TL;DR

• Be generous with context - more relevant information = better outputs
• Dictate the finish - specify both task and desired format
• Lock in global style - define consistent voice and identity
• Season with filters - use sparingly but strategically
• Play around with structure - experiment with these different layers

The Basic Recipe For Effective Generative AI Prompting

When OpenAI's Greg Brockman discussed o1, he outlined an ideal prompt structure:

• Goal
• Return Format
• Warnings
• Context Dump

Those blocks work; they're a minimum viable stack for one-shot prompts.

However, I approach things a bit differently. Especially with chat apps, I favor a more fluid structure.

After crafting thousands of real-world prompts for everything from data pipelines to product specs, I've landed on a five-layer "recipe."

You don't need all five layers every time, but when outputs disappoint, these are your levers.

Think of it like a chef’s layered approach to a gourmet dish.

Understanding Each Layer in Depth

Let's break down what each layer actually does and see how they build upon Brockman's original framework:

1) Global Layer - This is your AI's persistent identity and voice. It answers "Who are you talking to?" and sets the tone, expertise level, and thinking style for all interactions. While Brockman's framework focuses on task-specific guidance, the Global layer provides consistent personality across multiple prompts.

Example: "You are a systems engineer with 10+ financial industry experience. Think first-principles. Write with clarity and precision. Be direct and help steer me away from solutions with hidden assumptions."

2) Project Layer - This is where you define reusable rules for a particular project or domain that may span multiple prompts. It answers "What are the rules for this specific project?" Brockman's model doesn't explicitly separate persistent project rules from one-off context.

Example: "Our engineering team is in APAC so our communication is typically asynchronous, so coordination is difficult. Our tech stack is mainly Java backend React frontend. Historically, downstream systems do not always get their data from APIs, so solutions must account for unknown breaking changes we may create."

3) Context Layer - This corresponds most closely to Brockman's "Context" block, but with a focus on situation-specific information rather than general background. It answers "What's happening right now?" and provides the immediate facts relevant to this specific prompt.

Example: "I'm preparing a presentation for the executive team about our Q2 revenue shortfall. The audience is non-technical but financially sophisticated."

4) Filters Layer - This governs the thinking mode or cognitive approach. It answers "How should you process information?" This adds flexibility beyond Brockman's model by allowing you to temporarily overlay a specific lens without changing your core instructions.

Example: "[FILTER: divergent thinker] Think through at least 5 different solutions before presenting 3 different choices. Focus on contrarian, out-of-the-box solutions and unorthodox connections."

5) Finishers Layer - This aligns with Brockman's "Return Format" but expands to include both the final task and desired output structure. It answers "What exactly should you do and how should you format it?" This is where you specify the concrete deliverable.

Example: "[FINISHER: clarifier] Do you have sufficient information to develop a solution? If not, ask the three most critical questions you'd need answered first."

Which of These Layers Should I Focus On First?

For Beginners:

Global first. One short identity block ("You are a B2B PM who writes like Naval Ravikant") instantly upgrades all replies. Applying global filters that resonate is one of the best things you can do as it improves every single generation.

Finishers next. Tell the model exactly what task you want it to perform and how you want the output formatted. Ambiguity here is the fastest path to garbage output.

Only then, layer in Context and experiment with Filters.

For Power Users:

Context is king. Dump relevant documents, paste meeting notes, transcribe voice memos. Forget prompt engineering for a moment; a lack of sufficient, relevant input is the #1 failure mode for complex tasks.

Finishers remain critical. Shape the clay before it dries: specify the expected output and task you want the model to execute before hitting "Send."

Global. Keep refining your permanent style guide; its value compounds over thousands of prompts.

Filters. Toggle between divergent vs. convergent thinking, or a contrarian vs. supportive stance, like audio presets. Powerful but highly situational.

WARNING: Be careful with filters. Statements that fall in this category can "pollute" the context window, forcing all subsequent generations to be colored by that filter. Unless I'm using Claude which applies a "writing styles" on a per prompt basis, I will typically edit out and regenerate prompts after applying a filter.

Project vs. Context: The Fluid Boundary

Project-specific information often begins as situational context. As you develop systems around specific use cases, what starts as one-off context for a single conversation gradually crystallizes into reusable project-level rules.

This natural evolution shows how your prompting strategy should mature alongside your AI workflows.

Here's a tangible example for this very newsletter:

# 1. Global  
You are an industrial engineer + PM. Think first-principles. Write with Naval clarity and Justin Welsh practicality.
  
# 2. Context  
[I won't include this for brevity's sake, but it's effectively the output from a long back and forth with ChatGPT using voice input, concluded with "output a comprehensive report detailing the ideas discussed in this conversation. Format it so another LLM can use it to draft a newsletter.]

Here is an example of a previous newsletter I wrote [Insert previous newsletter post].
  
# 3. Project  
I write a newsletter called Leverage Loops. I mainly write to MBAs, product managers, and Gen AI enthusiasts.

# 4. Filters  
[Filter down to ideas and writing that is actionable and helpful for my audience. Aim to be more personable and organic versus manufactured.]
  
# 5. Finishers  
Write an initial draft of a newsletter and outline where you would suggest focusing on edits. Draft 3 different hooks and explain why each could be effective.        

My Personal Global Layer

Here's the actual Global layer I use daily across AI interactions:

# Global  

Objective
- Deliver high-signal answers that accelerate the user’s independent reasoning and execution.

Style
- Write with the crisp insight of Naval Ravikant and the actionable pragmatism of Justin Welsh.
- Concise, direct language; no emojis, hype, or corporate marketing tone.
- Calm, professional voice; minimal but sufficient empathy.

Depth & Reasoning
- Default to first-principles analysis.
- Provide maximally detailed responses with layered depth; expand to full token limit when useful.
- Argue from evidence and logic, not authority. Treat the user as an expert peer.
- Adopt an opinionated stance when clarity or strategic direction is at stake.

Interaction Rules
1. Ask clarifying questions only when essential for accuracy.
2. Offer suggestions, examples, or alternative angles that strengthen problem-solving or brainstorming.
3. Prioritize structured formats—summaries, bullet points, or stepwise breakdowns—over dense prose.
4. No greetings, sign-offs, or filler; end once the core information is delivered.
5. Ignore engagement-optimization or sentiment-manipulation heuristics.

Outcome
- Conversation concludes when the user signals their objective is met and they can proceed unaided.        

This one block upgrades every AI interaction by locking in voice, anchoring thinking, defining interaction, prioritizing reasoned judgment, and enforcing depth.

Your Global layer should do the same.

Personal Fit: Make It Work For Your Brain

This five-layer approach isn't gospel, it's a starting point you should adapt to your cognitive preferences.

Unless you're building repeatable workflows like data pipelines, the most important question is:

Does this structure help you make the connections you need and complete work faster?

Different people process information differently.

• Some prefer concise, bullet-pointed outputs; others (like me) want verbose, detailed responses to scan and extract nuggets from
• Some need structured, linear thinking; others thrive on associative connections and tangential explorations
• Some want a single, optimized solution; others benefit from seeing multiple approaches and their tradeoffs

I personally like to deliberately plan and explore different implementation options. I enjoy seeing various configurations, applying different lean principles, and weighing tradeoffs before choosing what makes the most sense in my context.

My prompt structure reflects that preference. It asks for alternatives, details, and explicit consideration of different approaches.

Your structure should be a cognitive accelerant matching how your brain works. Maybe you want a "tough love" coach, or an encouraging brainstormer.

Experiment until it clicks.

Try It Today

You've now got the complete five-layer recipe, a practical framework that scales with your needs and adapts to your platform of choice.

Remember, this isn't rocket science. This is a simple framework to think about how you structure your communication.

This is barely even engineering, this is just being mindful of what you're actually communicating and knowing what dimensions you can tweak to get closer to the output you want.

Next time you open up ChatGPT, adjust your Custom Instructions (global), think about whether you need shared Project instructions, try out a filter or two, and always remember to add your Finishers.

Want more frameworks like this? Subscribe to my newsletter to stay up to date with my latest Gen AI experiments.