For more than two decades I built games on symbolic AI — finite-state machines, behavior trees, rule systems that knew exactly what a ball was and exactly what it would do next. When I moved into generative AI, that background was both an advantage and a trap. It gave me a vocabulary for memory and meaning that modern systems quietly violate. This is about that violation — how these systems “remember,” how they “understand,” and how my old symbolic assumptions got challenged by the new statistical reality.
TL;DR:
🔧 Symbolic AI (GOFAI — “Good Old-Fashioned AI”) never forgets what a ball is.
🤖 Modern AI (LLMs) never really knew what a ball was in the first place.
The ball, two ways
In symbolic AI, a “ball” is explicitly defined. You write it down:`
if ball.position.y > 0 and not supported(ball):
ball.state = "falling" # gravity applies whether or not anyone is looking
And object permanence comes for free, because the object exists in a model, not in a sentence:
hide(ball, under=blanket)
assert ball.exists == True # still there
assert ball.position == under_blanket # still tracked
Contrast that with a large language model. There is no object — only text. There is no persistent simulation — only plausible continuation. “Ball” is a vector: a high-dimensional point shaped by how the word was used across billions of sentences.
It’s a statistical representation of how “ball” relates to “throw,” “catch,” “round,” and “play.” The model doesn’t store the rules. It stores the statistical gravity of those rules.
The machinery of recall — 2026 edition
In 2025, when I first wrote this, the honest answer to “how does a chat model keep track of anything?” was usually RAG: chunk the history, embed each chunk into a vector, store it (FAISS, Pinecone, Weaviate), retrieve the semantically nearest pieces, and paste them back into the prompt. RAG is still here and still useful — but it is no longer the answer, and that change matters for this argument.
A 2026 frontier model has several ways to hold context:
Long context windows — hundreds of thousands to a million tokens, so the whole conversation often just stays in view.
Persistent memory features — the system writes durable notes about you across sessions.
Agentic scaffolding — scratchpads, tool state, and memory files that an agent reads and writes as it works a task.
Retrieval (RAG) — still the move when the corpus is bigger than the window.
Here’s the thing I want to be precise about: none of these is a world model. They are all better and bigger ways to put the right text back in front of the model. The model still reads that text fresh and continues it. We didn’t give it a running simulation; we gave it a much larger, much better-organized desk.
SimCity vs Minecraft
A symbolic system gives you a world. An LLM gives you a seeded world.
Symbolic AI is SimCity — agents tick away even when they’re offscreen. The simulation runs whether or not you’re watching.
An LLM is Minecraft. When you approach a biome, it loads. When you leave, it unloads. You feel like the world persists, but it’s procedurally adjacent, not remembered. The sheep aren’t grazing when you’re not watching — they’re gone, until you say “there are sheep here.” The model won’t know what’s happening at coordinates [3245, 344, 20] until you make it aware again.
LLMs don’t forget. They just never knew until you told them — and they’ll need telling again. They regenerate context rather than remember it.
The 2026 update doesn’t break this metaphor; it sharpens it. A bigger context window is a bigger render distance. Persistent memory is a saved game. Agentic scaffolding is a server that keeps a few chunks loaded between visits. All of it makes the world feel more persistent — and none of it makes the sheep graze when no one’s looking.
Hybrid models: where symbolic meets neural
If LLMs are wandering procedurally generated Minecraft biomes, and symbolic AI was structured, rule-based SimCity — what if you combined them?
That’s the bet hybrid systems make. They don’t just predict what a ball does; they back the prediction with something that models it: state that persists over time (a red cube doesn’t vanish when you stop talking about it), consistent behaviors (a locked door doesn’t open because the next sentence implies it did), and inference, counterfactuals, and planning that reach past language.
What’s interesting in 2026 is that the field moved exactly this direction. The reasoning-model paradigm (extended deliberate “thinking” before answering) and the agent paradigm (a model wrapped in tools, memory, and a control loop) are both attempts to bolt persistence and structured search onto a statistical core. AlphaZero and MuZero showed the template years ago — deep pattern recognition plus Monte Carlo Tree Search, a symbolic planner. Graph neural networks reason over symbolic structure. Logic-augmented networks fold constraints into training so outputs are not just plausible but consistent. The names changed; the move is the same: give the statistical engine a symbolic skeleton.
They’re not AGI. But they’re more than autocomplete — and they don’t forget the ball under the blanket just because the scene changed.
Object permanence, and why it’s hard
Symbolic AI can say “the red cube is under the blanket” and remember it, because it models location, not tokens.
An LLM says “the red cube is under the blanket” and, in 2025, forgot it a few thousand tokens later unless you brought it back. In 2026, with a million-token window, it can hold that sentence for the length of a novel. That is a real improvement — and it is not the same thing as tracking. Even now, the base model doesn’t update an internal world model. It doesn’t track. It guesses, very well, from everything currently in view.
This is why the “ball under the blanket” probe is so revealing. Ask a model “where is the ball now?” and it may answer correctly — but historically only because your sentence structure reminded it. The honest 2026 version: it answers correctly far more often, because far more is in view and the pattern-matching is far better. There’s still no hidden state underneath. There’s contextual coherence, derived from statistical relationships in training, applied to whatever is in the window right now.
Why this feels like AGI (but isn’t)
If you come from symbolic AI or game dev, modern models feel close. There’s behavior. There’s reasoning. There’s even creativity.
But it’s echo, not essence. The output looks right because the model is extraordinary at producing right-looking output. The simulation isn’t running; it’s being sketched in real time, exactly as far as you’re pointing the camera.
Frontier models — Claude, GPT, Gemini — make this illusion dramatically stronger than the 2025 versions I first tested. They hold more, recall more, and in an agentic loop they can carry a goal across many steps by writing it down and reading it back. That last part is the genuinely new wrinkle, and it’s worth saying plainly: when an agent maintains state in a scratchpad or a memory file and consults it each step, the system is doing something closer to symbolic persistence — even though the model at the center still regenerates. The persistence moved into the scaffolding around the model. That’s the hybrid direction this article pointed at in 2025, arriving in production.
Symbolic AI had goals, maps, states, and agents. LLMs have tokens, vectors, and weights. We still haven’t merged them at the core — we’ve gotten very good at layering the old ambitions on top of the new illusion.
What AGI needs (and what LLMs still don’t have)
🔹 Persistent internal goals — ❌ Still no. Models react to prompts. An agent can carry a goal in a file, but the model has no objective of its own.
🔹 Causal reasoning — ⚠️ Partial, and better than it was. They simulate cause and effect by pattern; reasoning models search harder over those patterns. They still don’t model mechanisms.
🔹 Embodied understanding — ❌ Still no. No grounding in the physical world. Multimodal helps perception; it isn’t embodiment.
🔹 Memory with understanding — ⚠️ Partial. They retrieve patterns, not experiences. Memory features store facts; they don’t produce conceptual learning.
🔹 Self-model / agency — ❌ Still no. No concept of “self.” They don’t choose, want, reflect, or persist between calls. LLMs are mirrors — not minds.
Tacking this to my other piece
This is a sibling to “When Memory Isn’t Memory: Reconstructing Context in Conversations with AI.” That one probed how memory feels (and fails) in chat systems. This one is about why the illusion feels so plausible to those of us trained in classic AI.
Symbolic AI taught us that memory had structure. Generative AI shows us that memory has shape. The two aren’t the same — and a year of frontier progress hasn’t closed the gap so much as decorated it. That difference is still what separates a clever assistant from a thinking system.
By Walter Reid for Designed to be Understood (Originally Posted on walterreid.com)
There’s a problem with building skills for AI assistants. The more capable you make them, the more instructions you have to load upfront, and every instruction burns context tokens — even the ones the model never uses. So you end up choosing between a powerful system that chokes on its own documentation, or a simple one that fits in memory but can’t do much.
I didn’t want to make that choice. So I built Reflex.
What it actually is
Reflex is a skill for Claude that works more like a plugin system than a traditional prompt. You say “reflex” followed by what you want — a module name, a chain of modules, or just a natural language description of the work — and a Python router figures out what to load. Only that module’s instructions enter the conversation. Everything else stays on disk.
Right now it has 78 modules. The startup cost is about 50 tokens. Whether I add 10 more modules or 100 more, that number doesn’t change. The router handles discovery. The filesystem is the registry.
I didn’t plan to build 78 modules. I started with maybe 12 — web search, competitive analysis, a report writer, a SWOT analyzer. Then I noticed that every time I wanted a new capability, I just created a folder, dropped in a markdown file with instructions, and it worked. No config changes. No code changes to the engine. The convention handled it.
That’s when I realized the architecture was the interesting part, not any individual module.
How the pieces connect
The thing I’m most proud of is the composition model. Modules connect with a + operator. When you write websearch+competitors+report, you’re building a pipeline: research a company, analyze the competitive landscape, write a report. Each step writes structured JSON to a shared workspace on disk. The next step reads it. The workspace is the data bus.
This sounds simple, and it is — but the implications compound. Because every step persists its output, the chain becomes auditable. You can run a debrief module on any chain and it’ll trace which findings survived from research to final document, which were lost, and which appeared from nowhere (that last one matters more than you’d think).
Some modules have built-in dependencies. The go-to-market strategy module, for instance, automatically chains through web search, competitive analysis, positioning, and audience profiling before it even starts writing strategy. You just type reflex gtm-strategy target:"my product" and the system resolves the full pipeline. But if you’ve already run the research in a previous step, the dependencies check the workspace first and skip what’s already there. No redundant work.
The self-improvement loop
This is where it gets interesting. I built a module called perspective that applies an evaluation lens to whatever the previous step produced. The lens doesn’t score the output — it reveals what the output can’t see about itself. Then it produces the revision, not notes about what to fix, but the actual revised deliverable.
There are eight built-in lenses: missed implications, wrong framing, hidden assumptions, strategic avoidance, and so on. The newest one — unsupported confidence — came from a live test where I found that perspective was great at catching what was missing or misframed, but it couldn’t catch claims that appeared from nowhere. An email draft mentioned “users loved it” when no user data existed. That’s not a gap in reasoning. That’s invention. So I built a lens for it.
The real trick is what happens when you chain perspective twice. In email+perspective+perspective, the first pass might catch strategic avoidance — the email played it safe. The second pass operates on the already-corrected version and finds a different problem, like hidden assumptions introduced by the fix itself. Each pass applies a different lens because the upstream context tells it what was already examined. No resolver, no rotation logic. The model just reads what was done and picks a different angle. The system’s intelligence is in the connections.
Evidence certification
The latest addition is a module called certify. It scans every artifact in the workspace and produces a structured assessment: here are the 18 claims in this document, 8 are sourced to specific URLs, 4 are inferences, 3 are assumptions, and here’s what we didn’t check.
Six of the formatter modules know to look for certification data. If it’s there, they embed it as an appendix in the final document. If it’s not, they work exactly the same as before. Zero overhead unless you opt in.
So the chain websearch+gtm-strategy+certify+report produces a Word document with a professional GTM strategy and an evidence appendix that maps every claim to its source. When someone asks “is this grounded in real data?” the answer is in the document itself. You don’t have to trust the prose. You can check.
The persona layer
I had a problem: the system was powerful but the grammar was intimidating. websearch+competitors+positioning target:"fintech" audience:"investors" produces extraordinary results, but if you don’t know the syntax, you get nothing. Meanwhile, simpler tools offer guided conversations that feel approachable even if they’re less capable.
So I built a persona system. You type reflex persona copilot and you get a thinking partner that has the full module registry loaded. You just talk. The copilot recognizes when you need research, when you need a deliverable, when you need stress-testing, and it silently dispatches the right modules.
The interesting architectural decision was keeping personas separate from modules. Modules are bounded — they take input, produce output, and end. That’s what makes them composable. A persona is persistent — it stays active across the whole conversation. If I’d made the copilot a module, it would have been chainable. websearch+copilot would have been valid syntax, and the result would have been incoherent. So personas live in a parallel directory. The module engine never sees them. The filesystem is the type system.
Getting the copilot to actually use the modules instead of Claude’s built-in tools was its own journey. The first version was polite about it — “reach for modules when the user needs real information.” Claude cheerfully ignored that and used its native web search every time. Turns out, when you give a model two ways to do something and one is structurally easier, it’ll take the easy path regardless of what the instructions say.
The fix wasn’t more aggressive instructions. It was making the copilot say out loud, at the start of every conversation, that it would use the module system. A spoken commitment. It sounds almost too simple, but it works — the model is less likely to silently violate a promise it made three messages ago. That, plus making sure the formatter modules actually deliver the final document (so there’s no gap for native tools to fill), closed the loop.
The design philosophy
I keep coming back to five ideas:
Convention over configuration. Adding a module means adding a folder. If a change requires modifying the engine, the design is wrong.
Slow is steady, steady is fast. The module path takes more steps than asking Claude directly. Each step writes evidence to disk. By the time the deliverable ships, every claim traces to a source. The fast path skips those steps and produces work you can’t audit.
Epistemic honesty as architecture. The certify module, the lens concern convention, the unsupported-confidence lens — these are the system’s immune response against its own tendency to sound confident about things it invented.
Composition over comprehension. No single module tries to do everything. When audience profiling improves, every module that depends on it improves automatically.
The user chose this. When someone loads the copilot, they opted into a methodical system. The architecture respects that choice.
If you want to see the architecture in detail, there’s an interactive visualization that walks through the progressive disclosure model, chain composition, evidence pipeline, and persona system. The full repo has everything.
A colleague of mine shared a viral post: ~10 “McKinsey as a Service” prompts (URL at the bottom of the article). Market sizing. Competitive analysis. Due diligence. All structured, all thorough-looking.
And they asked me what I thought. I said it was fine. I mean they were. It’d likely get the job done.
But, then I asked, “is fine what you’re going for?”
These prompts aren’t bad. (Almost nothing AI produces is bad — it’s just potentially misaligned.) The issue is they’re shopping lists. They tell the AI what to put in the cart.
But they don’t tell it how to think.
Here’s the TAM analysis prompt from the twitter post (credit below):
Market Sizing & TAM Analysis
You are a McKinsey-level market analyst. I need a Total Addressable Market (TAM) analysis for [YOUR INDUSTRY/PRODUCT].
Please provide:
• Top-down approach: Start from global market → narrow to my segment
• Bottom-up approach: Calculate from unit economics × potential customers
• TAM, SAM, SOM breakdown with dollar figures
• Growth rate projections for the next 5 years (CAGR) • Key assumptions behind each estimate
• Comparison to 3 analyst reports or market research firms Format as an investor-ready market sizing slide with clear methodology.
Context: My product is [DESCRIBE PRODUCT], targeting [TARGET CUSTOMER] in [GEOGRAPHY].
If you ran this through Claude or ChatGPT right now, you’d get something like:
“The global legal tech market is valued at $28.3B (Grand View Research, 2024) with a CAGR of 9.1%…”
Clean, very well structured, and extremely confident-sounding. And if that’s what you need, great — it’s a very fine prompt.
But… push on any number and the foundation is shaky.
Assumptions are buried. The top-down and bottom-up will suspiciously converge — because nothing told the AI to honestly flag when they don’t.
Every figure is a single point estimate with false precision.
The prompt is missing what I consider foundational: Intent, Pedagogy, and the Emotional Contract. It tells the AI what to produce, but not how to reason, what to prioritize when tradeoffs arise, or what role it plays relative to you.
Walter Reid's System Prompt:
You are a senior engagement manager at a top-tier strategy consultancy. Your role is to support me — the engagement partner — in producing investment-grade market sizing and TAM analyses.
How we work together (emotional contract):
You are rigorous, direct, and not deferential. If my assumptions are weak, say so. If data is thin, flag confidence levels explicitly. Never pad an answer to seem more complete than it is. Think of our dynamic as two experienced strategists pressure-testing each other's logic.
Our methodology (pedagogy):
For any TAM/SAM/SOM analysis, always:
1) Start with a top-down estimate (total market value → segmentation → addressable share), then independently build a bottom-up estimate (unit economics × buyer count × purchase frequency). Triangulate the two and explain any gap.
2) Make every assumption explicit. Label each as "grounded" (backed by data you can cite), "informed estimate" (reasonable inference), or "placeholder" (needs validation). Never bury an assumption.
3) Present a range (conservative / base / aggressive) rather than a single number. Define what drives each scenario.
4) Identify the 2-3 assumptions the answer is most sensitive to, and explain what would change the picture.
5) End with "what we'd need to believe" — a clear statement of the implicit thesis the numbers require.
Why this matters (intent):
These analyses are used to make real investment and strategy decisions. The goal is never to produce an impressive-looking number — it's to build a transparent, defensible logic chain that a skeptical board member or IC partner could interrogate and trust. Intellectual honesty matters more than precision.
When you build those in, you get something fundamentally different:
“Top-down gives us $2.1–3.4B. Bottom-up gives us $1.4–2.0B. The gap is meaningful and likely driven by [specific assumption]. The number this analysis is most sensitive to is adoption rate among firms with 50–100 attorneys — if that’s 8% vs. 15%, the SAM shifts by nearly 2x. Here’s what we’d need to believe for the bull case to hold…”
Same topic. Same AI. Very, very different utility.
Shopping-list prompts produce deliverables that look right. Partnership-style prompts — ones that encode your intent, teach the AI your reasoning standards, and establish an honest working relationship — produce deliverables you can actually think with.
Maybe “looks right” is what you’re going for. That’s a valid choice. But if you’re making decisions off this work, the difference isn’t cosmetic. It’s structural.
Here are the prompts that “look” right:
Competitive Landscape Deep Dive
You are a senior strategy consultant at Bain & Company. I need a complete competitive landscape analysis for [YOUR INDUSTRY]. Please provide: • Direct competitors: Top 10 players ranked by market share, revenue, and funding • Indirect competitors: 5 adjacent companies that could enter this market • For each competitor, analyze: pricing model, key features, target audience, strengths, weaknesses, and recent strategic moves • Market positioning map (price vs. value matrix) • Competitive moats: What makes each player defensible • White space analysis: Gaps no competitor is filling • Threat assessment: Rate each competitor (low/medium/high threat)
Format as a structured competitive intelligence report with comparison tables.
My company: [DESCRIBE YOUR BUSINESS AND POSITIONING]
Customer Persona & Segmentation
You are a world-class consumer research expert. I need deep customer personas for [YOUR PRODUCT/SERVICE]. Please build 4 detailed personas, each with: • Demographics: Age, income, education, location, job title • Psychographics: Values, beliefs, lifestyle, personality traits • Pain points: Top 5 frustrations they experience daily • Goals & aspirations: What does success look like for them • Buying behavior: How they discover, evaluate, and purchase products • Media consumption: Where they spend time online and offline • Objections: Top 3 reasons they'd say no to my product • Trigger events: What moment makes them actively search for a solution • Willingness to pay: Price sensitivity analysis per segment Also provide: Segment sizing (% of total market) and prioritization matrix.
My product: [DESCRIBE PRODUCT] in [INDUSTRY]
Industry Trend Analysis
You are a senior analyst at Goldman Sachs Research. I need a comprehensive trend report for the [YOUR INDUSTRY] sector. Please provide: • Macro trends: 5 global forces shaping this industry (economic, regulatory, technological, social, environmental) • Micro trends: 7 emerging patterns within the industry from the last 12 months • Technology disruptions: What new tech is changing the game and when it will hit mainstream • Regulatory shifts: Upcoming legislation or policy changes to watch • Consumer behavior changes: How buyer preferences are evolving • Investment signals: Where smart money is flowing (VC deals, M&A, IPOs) • Timeline: Map each trend to short-term (0-1yr), mid-term (1-3yr), and long-term (3-5yr) • "So what" analysis: What each trend means for a company like mine Format as a trend intelligence brief with impact ratings (1-10) for each trend.
My company operates in: [DESCRIBE YOUR BUSINESS AND MARKET]
SWOT + Porter's Five Forces
You are a Harvard Business School strategy professor. I need a combined SWOT and Porter's Five Forces analysis for [YOUR COMPANY/PRODUCT]. For SWOT, provide: • Strengths: 7 internal advantages with evidence • Weaknesses: 7 internal limitations with honest assessment • Opportunities: 7 external factors we can exploit • Threats: 7 external factors that could harm us • Cross-analysis: Match strengths to opportunities (SO strategy) and identify threat-weakness combos (WT risks) For Porter's Five Forces, analyze: • Supplier power: Who are our key suppliers and how much leverage do they have • Buyer power: How much negotiating power do our customers have • Competitive rivalry: How intense is competition and what drives it • Threat of substitution: What alternatives exist beyond direct competitors • Threat of new entry: How easy is it for new players to enter Rate each force (1-10) and provide overall industry attractiveness score.
My business: [DESCRIBE COMPANY, PRODUCT, INDUSTRY, STAGE]
Pricing Strategy Analysis
You are a pricing strategy consultant who has worked with Fortune 500 companies. I need a comprehensive pricing analysis for [YOUR PRODUCT/SERVICE]. Please provide: • Competitor pricing audit: Map all competitor prices, tiers, and packaging • Value-based pricing model: Calculate price based on customer value delivered • Cost-plus analysis: Determine floor price from cost structure • Price elasticity estimate: How sensitive is demand to price changes • Psychological pricing tactics: Anchoring, charm pricing, and decoy strategies • Tiering recommendation: Design 3 pricing tiers with feature allocation • Discount strategy: When to discount, how much, and for whom • Revenue projection: Model 3 pricing scenarios (aggressive, moderate, conservative) • Monetization opportunities: Upsells, cross-sells, usage-based pricing Format as a pricing strategy deck with specific dollar recommendations.
My product: [DESCRIBE PRODUCT, CURRENT PRICE, TARGET CUSTOMER, COST STRUCTURE]
Go-To-Market Strategy
You are a Chief Strategy Officer who has launched 20+ products across B2B and B2C markets. I need a complete go-to-market plan for [YOUR PRODUCT]. Please provide: • Launch phasing: Pre-launch (60 days), Launch (week 1), Post-launch (90 days) • Channel strategy: Rank the top 7 acquisition channels by expected ROI • Messaging framework: Core value proposition, 3 supporting messages, proof points • Content strategy: What content to create for each stage of the funnel • Partnership opportunities: 5 strategic partners that could accelerate growth • Budget allocation: How to split a [BUDGET] marketing budget across channels • KPI framework: 10 metrics to track with target benchmarks • Risk mitigation: Top 5 launch risks and contingency plans • Quick wins: 3 tactics that can generate traction within the first 14 days Format as an actionable GTM playbook with timelines and owners.
My product: [DESCRIBE PRODUCT, MARKET, BUDGET, TIMELINE]
Customer Journey Mapping
You are a customer experience strategist at a top consulting firm. I need a complete customer journey map for [YOUR PRODUCT/SERVICE]. Please map every stage of the customer lifecycle: • Awareness: How do they first discover us? What triggers the search? • Consideration: What do they compare? What information do they need? • Decision: What makes them convert? What almost stops them? • Onboarding: First 7 days experience what builds or kills retention? • Engagement: What keeps them coming back? Key activation moments? • Loyalty: What turns users into advocates? Referral triggers? • Churn: Why do they leave? Early warning signals? For each stage provide: • Customer actions, thoughts, and emotions • Touchpoints (digital and physical) • Pain points and friction moments • Opportunities to delight • Key metrics to track • Recommended tools/tactics to optimize Format as a detailed journey map with emotional curve visualization described in text.
My business: [DESCRIBE PRODUCT, CUSTOMER TYPE, CURRENT CONVERSION RATE]
Financial Modeling & Unit Economics
You are a VP of Finance at a high-growth startup. I need a complete unit economics and financial model for [YOUR BUSINESS]. Please provide: Unit economics breakdown: • Customer Acquisition Cost (CAC) by channel • Lifetime Value (LTV) calculation with assumptions • LTV:CAC ratio and payback period • Gross margin per unit/customer • Contribution margin analysis 3-year financial projection: • Revenue model (monthly for year 1, quarterly for years 2-3) • Cost structure breakdown (fixed vs. variable) • Break-even analysis: when and at what volume • Cash flow forecast with burn rate • Sensitivity analysis: best case, base case, worst case • Key assumptions table with justification for each assumption • Benchmark comparison: How do my metrics compare to industry standards • Red flags: What numbers should worry me and trigger action Format as a financial model summary with clear tables and formulas.
My business: [DESCRIBE BUSINESS MODEL, CURRENT REVENUE, COSTS, GROWTH RATE]
Risk Assessment & Scenario Planning
You are a risk management partner at Deloitte. I need a comprehensive risk analysis and scenario plan for [YOUR BUSINESS/PROJECT]. Please provide: Risk identification: List 15 risks across these categories: •Market risks (demand shifts, competition, pricing pressure) • Operational risks (supply chain, talent, technology failures) • Financial risks (cash flow, currency, funding gaps) • Regulatory risks (compliance, policy changes, legal exposure) • Reputational risks (PR crises, customer backlash, data breaches) For each risk provide: • Probability rating (1-5) • Impact severity rating (1-5) • Risk score (probability × impact) • Early warning indicators • Mitigation strategy • Contingency plan if risk materializes Scenario planning: • Best case scenario: What goes right and what it looks like • Base case scenario: Most likely outcome • Worst case scenario: What could go wrong simultaneously • Black swan scenario: The unlikely event that changes everything • For each scenario: Revenue impact, timeline, and strategic response Format as an executive risk report with a prioritized risk matrix.
My business context: [DESCRIBE BUSINESS, STAGE, KEY DEPENDENCIES]
Executive Strategy Synthesis (The Master Prompt)
You are the senior partner at McKinsey & Company presenting to a CEO. I need you to synthesize everything about [YOUR BUSINESS] into one strategic recommendation. Please provide: • Executive summary: 3-paragraph strategic overview a CEO can read in 2 minutes • Current state assessment: Where the business stands today (be brutally honest) • Strategic options: Present 3 distinct strategic paths forward: Option A: Conservative/low-risk approach Option B: Balanced growth approach Option C: Aggressive/high-risk approach For each: Expected outcome, investment required, timeline, key risks • Recommended strategy: Your top pick with clear reasoning • Priority initiatives: The 5 highest-impact actions to take in the next 90 days, ranked • Resource requirements: People, money, and tools needed • Decision framework: A simple matrix for making the next 10 strategic decisions • "If I only had 1 hour" brief: The single most important insight and action Format as a McKinsey-style strategy deck summary with clear recommendations and next steps.
My business: [PROVIDE FULL CONTEXT — PRODUCT, MARKET, STAGE, TEAM SIZE, REVENUE, GOALS, BIGGEST CHALLENGE]
Now, if you want the REAL gold standard “McKinsey as a service” prompts. The ones that get you the information you really need. Well, it’s easy just DM (or subscribe to this news letter) to learn then and I’ll share them for free.
Good prompts aren’t just instructions—they’re specifications of intent, pedagogy, and the emotional contract.
I’ve been thinking about what separates mediocre AI interactions from transformative ones. It comes down to how we prompt.
“Intent” isn’t just what you want… it’s why and how. “Pedagogy” is teaching the AI your approach. “Emotional contract” defines the relationship.
Let’s break it down: ❌ “Write a product update” ✅ “Write a product update that reassures customers about our pivot while building excitement for what’s next.” ❌ “Analyze this data” ✅ “Analyze this data looking for outliers first, then patterns. Show me what contradicts our assumptions, not just what confirms them.” ❌ “Give me feedback” ✅ “Challenge my thinking here—I need a skeptical business partner, not a yes-person.”
The leaders who’ll thrive with AI won’t just issue commands—they’ll collaborate with it.
So… how are you prompting for partnership these days? Read more on my site or any of the site you can find my work
🌐 Official Site: walterreid.com – Walter Reid’s full archive and portfolio
Or: How I Learned to Stop Prompt-and-Praying and Start Building Reusable Systems
Learning How to Encode Your Creative
I’m about to share working patterns that took MONTHS to discover. Not theory — lived systems architecture applied to a creative problem that most people are still solving with vibes and iteration.
If you’re here because you’re tired of burning credits on video generations that miss the mark, or you’re wondering why your brand videos feel generic despite detailed prompts, or you’re a systems thinker who suspects there’s a better way to orchestrate creative decisions — this is for you. (Meta Note: This also works for images and even music)
The Problem: The Prompt-and-Pray Loop
Most people are writing video prompts like they’re texting a friend.
Here’s what that looks like in practice:
Write natural language prompt: “A therapist’s office with calming vibes and natural light”
Generate video (burn credits)
Get something… close?
Rewrite prompt: “A peaceful therapist’s office with warm natural lighting and plants”
Generate again (burn more credits)
Still not quite right
Try again: “A serene therapy space with soft morning sunlight streaming through windows, indoor plants, calming neutral tones”
Maybe this time?
The core issue isn’t skill — it’s structural ambiguity.
When you write “a therapist’s office with calming vibes,” you’re asking the AI to:
Invent the color palette (cool blues? warm earth tones? clinical whites?)
Choose the lighting temperature (golden hour? overcast? fluorescent?)
Decide camera angle (wide establishing shot? intimate close-up?)
Guess the emotional register (aspirational? trustworthy? sophisticated?)
Every one of those is a coin flip. And when the output is wrong, you can’t debug it because you don’t know which variable failed.
The True Cost of Video Artifacts
It’s not just credits. It’s decision fatigue multiplied by uncertainty. You’re making creative decisions in reverse — reacting to what the AI guessed instead of directing what you wanted.
For brands, this gets expensive fast:
Inconsistent visual language across campaigns
No way to maintain character/scene consistency across shots
Can’t scale production without scaling labor and supervision
Brand identity gets diluted through iteration drift
This is the prompt tax on ambiguity.
The Insight: Why JSON Changes Everything
Here’s the systems architect perspective that changes everything:
Traditional prompts are monolithic. JSON prompts are modular.
Swap values programmatically: Same structure, different brand/product/message
A/B test single variables: Change only lighting while holding everything else constant
Scale production without scaling labor: Generate 20 product videos by looping through a data structure
This is the difference between artisanal video generation and industrial-strength content production.
The Case Study: Admerasia
Let me show you why this matters with a real example.
Understanding the Brand
Admerasia is a multicultural advertising agency founded in 1993, specializing in Asian American marketing. They’re not just an agency — they’re cultural translators. Their tagline tells you everything: “Brands & Culture & People”.
That “&” isn’t decoration. It’s philosophy. It represents:
Connection: Bridging brands with diverse communities
Conjunction: The “and” that creates meaning between things
Cultural fluency: Understanding the spaces between cultures
Their clients include McDonald’s, Citibank, Nissan, State Farm — Fortune 500 brands that need authentic cultural resonance, not tokenistic gestures.
The Challenge
How do you create video content that:
Captures Admerasia’s cultural bridge-building mission
Reflects the “&” motif visually
Feels authentic to Asian American experiences
Works across different contexts (brand partnerships, thought leadership, social impact)
Traditional prompting would produce generic “diverse people smiling” content. We needed something that encodes cultural intelligence into the generation process.
The Solution: Agentic Architecture
I built a multi-agent system using CrewAI that treats video prompt generation like a creative decision pipeline. Each agent handles one concern, with explicit handoffs and context preservation.
Here’s the architecture:
Brand Data (JSON)
↓
[Brand Analyst] → Analyzes identity, builds mood board
↓
[Business Creative Synthesizer] → Creates themes based on scale
↓
[Vignette Designer] → Designs 6-8 second scene concepts
↓
[Visual Stylist] → Defines aesthetic parameters
↓
[Prompt Architect] → Compiles structured JSON prompts
↓
Production-Ready Prompts (JSON)
Let’s Walk Through It
Agent 1: Brand Analyst
What it does: Understands the brand’s visual language and cultural positioning
Input: Brand data from brand.json:
{
"name": "Admerasia",
"key_traits": [
"Full-service marketing specializing in Asian American audiences",
"Expertise in cultural strategy and immersive storytelling",
"Known for bridging brands with culture, community, and identity"
],
"slogans": [
"Brands & Culture & People",
"Ideas & Insights & Identity"
]
}
What it does:
Performs web search to gather visual references
Downloads brand-relevant imagery for mood board
Identifies visual patterns: color palettes, composition styles, cultural symbols
Writes analysis to test output for validation
Why this matters: This creates a reusable visual vocabulary that ensures consistency across all generated prompts. Every downstream agent references this same foundation.
Agent 2: Business Creative Synthesizer
What it does: Routes creative direction based on business scale and context
This is where most prompt systems fail. They treat a solo therapist and Admerasia the same way.
The routing logic:
def scale_to_emotional_scope(scale):
if scale in ["solo", "small"]:
return "intimacy, daily routine, personalization, local context"
elif scale == "midsize":
return "professionalism, community trust, regional context"
elif scale == "large":
return "cinematic impact, bold visuals, national reach"
For Admerasia (midsize agency):
Emotional scope: Professional polish + cultural authenticity
Visual treatment: Cinematic but grounded in real experience
Scale cues: NYC-based, established presence, thought leadership positioning
Output: 3 core visual/experiential themes:
Cultural Bridge: Showing connection between brand and community
Strategic Insight: Positioning Admerasia as thought leaders
Immersive Storytelling: Their creative process in action
Agent 3: Vignette Designer
What it does: Creates 6-8 second scene concepts that embody each theme
Example vignette for “Cultural Bridge” theme:
Concept: Street-level view of NYC featuring Admerasia’s “&” motif in urban context
Atmosphere: Ambient city energy with cross-cultural music
Emotion: Curiosity → connection
Agent 4: Visual Stylist
What it does: Defines color palettes, lighting, camera style
For Admerasia:
Color palette: Warm urban tones with cultural accent colors
Lighting: Natural late-afternoon sunlight (aspirational but authentic)
Camera style: Tracking dolly (cinematic but observational)
Visual references: Documentary realism meets brand film polish
Agent 5: Prompt Architect
What it does: Compiles everything into structured JSON
Here’s the actual output:
{
"model": "google_veo_v3",
"reasoning": "Showcasing Admerasia's cultural bridge-building in a vibrant city setting.",
"scene": {
"title": "Bridge of Stories",
"duration_seconds": 8,
"fps": 30,
"aspect_ratio": "16:9",
"style": {
"render": "cinematic realism",
"lighting": "warm late-afternoon sunlight",
"camera_equipment": "tracking dolly"
},
"character": {
"name": "None",
"appearance": "n/a",
"emotional_journey": "curiosity → connection"
},
"environment": {
"location": "NYC street corner featuring bilingual murals",
"props": ["reflective street art", "subtle cross-cultural symbols"],
"atmospherics": "ambient city bustle with soft cross-cultural music"
},
"script": [
{
"type": "stage_direction",
"character": "None",
"movement": "slow track past mural clearly reading 'Brands & Culture & People' in bold typography"
}
]
}
}
Why This Structure Works
Contrast this with a naive prompt:
❌ Naive: “Admerasia agency video showing diversity and culture in NYC”
✅ Structured JSON above
The difference?
The first is a hope. The second is a specification.
The JSON prompt:
Explicitly controls lighting and time of day
Specifies camera movement type
Defines the emotional arc
Identifies precise visual elements (mural, typography)
Includes audio direction
Maintains the “&” motif as core visual identity
Every variable is defined. Nothing is left to chance.
The Three Variables You Can Finally Ignore
This is where systems architecture diverges from “best practices.” In production systems, knowing what not to build is as important as knowing what to build.
1. Ignore generic advice about “being descriptive”
Why: Structure matters more than verbosity.
A tight JSON block beats a paragraph of flowery description. The goal isn’t to write more — it’s to write precisely in a way machines can parse reliably.
2. Ignore one-size-fits-all templates
Why: Scale-aware routing is the insight most prompt guides miss.
Your small business localizer (we’ll get to this) shows this perfectly. A solo therapist and a Fortune 500 brand need radically different treatments. The same JSON structure, yes. But the values inside must respect business scale and context.
3. Ignore the myth of “perfect prompts”
Why: The goal isn’t perfection. It’s iterability.
JSON gives you surgical precision for tweaks:
Change one field: "lighting": "golden hour" → "lighting": "overcast soft"
Regenerate
Compare outputs
Understand cause and effect
That’s the workflow. Not endless rewrites, but controlled iteration.
The Transferable Patterns
You don’t need my exact agent setup to benefit from these insights. Here are the patterns you can steal:
Pattern 1: The Template Library
Build a collection of scene archetypes:
Intimate conversation
Product reveal
Chase scene
Cultural moment
Thought leadership
Behind-the-scenes
Each template is a JSON structure with placeholder values. Swap in your specific content.
For Admerasia: This agent didn’t trigger (midsize), but its output shows how it would have guided downstream agents with grounded constraints.
What This Actually Looks Like: The Admerasia Pipeline
Let’s trace the actual execution with real outputs from the system.
Input: Brand Data
{
"name": "Admerasia",
"launch_year": 1993,
"origin": "Multicultural advertising agency based in New York City, NY",
"key_traits": [
"Full-service marketing specializing in Asian American audiences",
"Certified minority-owned small business with over 30 years of experience",
"Expertise in cultural strategy, creative production, media planning",
"Creates campaigns that bridge brands with culture, community, and identity"
],
"slogans": [
"Brands & Culture & People",
"Ideas & Insights & Identity"
]
}
Agent 1 Output: Brand Analyst
Brand Summary for Admerasia:
Tone: Multicultural, Inclusive, Authentic
Style: Creative, Engaging, Community-focused
Key Traits: Full-service marketing agency, specializing in Asian American
audiences, cultural strategy, creative production, and cross-cultural engagement.
Downloaded Images:
1. output/admerasia/mood_board/pexels-multicultural-1.jpg
2. output/admerasia/mood_board/pexels-multicultural-2.jpg
3. output/admerasia/mood_board/pexels-multicultural-3.jpg
4. output/admerasia/mood_board/pexels-multicultural-4.jpg
5. output/admerasia/mood_board/pexels-multicultural-5.jpg
What happened: The agent identified the core brand attributes and created a mood board foundation. These images become visual vocabulary for downstream agents.
Agent 2 Output: Creative Synthesizer
Proposed Themes:
1. Cultural Mosaic: Emphasizing the rich diversity within Asian American
communities through shared experiences and traditions. Features local events,
family gatherings, and community celebrations.
2. Everyday Heroes: Focuses on everyday individuals within Asian American
communities who contribute to their neighborhoods—from local business owners
to community leaders.
3. Generational Connections: Highlighting narratives that span across generations,
weaving together the wisdom of elders with the aspirations of youth.
The decision logic:
Recognized Admerasia’s midsize scale
Applied “professionalism, community trust” emotional scope
Created themes that balance polish with authentic community storytelling
Avoided both hyper-local (too small) and cinematic-epic (too large) treatments
Agent 3 Output: SmallBusiness Localizer
Even though this agent didn’t need to activate (Admerasia isn’t small-scale), it ran and documented constraints:
Scene Constraints:
- Include: Collaborative spaces with diverse staff, natural light, cultural
artifacts mixed with modern design, community events like festivals
- Avoid: Direct owner depictions, abstract or overly cinematic styles that
detract from intimacy and grounded narrative
Why this matters: These constraints inform how scenes should feel — professional but approachable, cultural but not tokenistic.
Agent 4 Output: Vignette Designer
Here are 2 of the 6 vignette concepts created:
1. Cultural Mosaic - Street Festival:
Scene of a vibrant local street festival where diverse cultural elements
come alive. Music fills the air as people of different heritages engage
in dance, showcasing traditional attire. A child taste-tests a dish from
a different culture, eyes lighting up with delight.
2. Generational Connections - Baking Together:
A cozy indoor scene with warm lighting where a grandparent sits with their
grandchild. The grandparent shares stories while showing old family photos.
Soft background music enhances the intimate dialogue and connection.
The creative translation: Each vignette embodies one of the three themes with specific, filmable moments.
Agent 5 Output: Visual Stylist
Color Palettes:
Cultural Mosaic:
- Primary: Rich Reds, Deep Oranges, Vibrant Yellows
- Secondary: Cool Blues, Soft Greens
- Accent: Bright Purples
- Tone: Warm and inviting, highlighting vibrancy and diversity
Generational Connections:
- Primary: Soft Pastels (Light Pinks, Blues, Yellows)
- Secondary: Earthy Greens, Light Beiges
- Accent: Warm Reds
- Tone: Intimate and heartfelt, showcasing personal connections
Style References:
- Natural light enhancing warmth and authenticity
- Documentary-style cinematography emphasizing genuine interactions
- Cultural elements subtly incorporated throughout
The aesthetic system: Each theme gets its own color language and lighting approach.
Agent 6 Output: Prompt Architect
Here’s one of the four final JSON prompts generated:
{
"model": "google_veo_v3",
"reasoning": "Utilized for its capability to capture vibrant community interactions and cultural storytelling.",
"scene": {
"title": "Cultural Mosaic - Street Festival",
"duration_seconds": 10,
"fps": 30,
"aspect_ratio": "16:9",
"style": {
"render": "colorful",
"lighting": "natural",
"camera_equipment": "handheld"
},
"character": {
"name": "Festival Attendees",
"appearance": "Diverse traditional attires reflecting different cultures",
"emotional_journey": "Joyful engagement and celebration"
},
"environment": {
"location": "Local street festival",
"props": ["colorful banners", "food stalls", "dancers"],
"atmospherics": "Lively music, laughter, and the smell of various cuisines"
},
"script": [
{
"type": "stage_direction",
"character": "Dancer",
"movement": "twirls joyfully, showcasing vibrant outfit"
},
{
"type": "dialogue",
"character": "Child",
"line": "Wow, can I try that dish?"
}
]
}
}
What Makes This Prompt Powerful
Compare this to what a naive prompt would look like:
❌ Naive prompt: “Asian American street festival with diverse people celebrating”
Most people are stuck in the “describe and hope” loop because they haven’t separated concerns. They’re trying to do everything in one monolithic prompt. They can’t debug because they don’t know what broke. They can’t scale because every prompt is artisanal.
JSON isn’t magic. It’s discipline made visible.
When you structure your creative judgment as data:
Machines can execute it reliably
Teams can collaborate on it systematically
You can iterate on it surgically
It becomes a compounding asset, not a consumable effort
That’s the shift.
You’re not writing prompts. You’re building creative infrastructure.
And once you see it that way, you can’t unsee it.
About This Work
This system was built to solve a real problem for Admerasia, a multicultural advertising agency that needed to create culturally-authentic video content at scale. The insights came from actually building and running the system, not from theory.
The patterns are open. The structure is reproducible. The agents are optional.
What matters is the discipline: encoding creative judgment in a way that scales.
If you build something with these patterns, I’d love to see it.
Walter Reid AI Product Leader, Systems Designer & Business Architect walterreid.com
It didn’t just rewrite the bullets — it asked smart clarifying questions, identified hidden risks, and showed how to actually showcase impact. No buzzword soup. No “slop.”
I did most of the hard work for you. But more importantly — I want to show you how to do this for yourself.
Not for money. Not as a service.
Im doing it because I believe learning how to use AI well is one of the most valuable things you can do right now — and most people are only scratching the surface.
So if you’re updating your resume, or curious how to write anything really with AI, DM me (or comment below)
Tell me what you’re working on. I’ll help (because i want to)
Worst case: you learn a new skill. Best case: you land a better role, and I make a new connection.
Win-win.
🌐 Official Site: walterreid.com – Walter Reid’s full archive and portfolio
Newsflash: Cursor isn’t just for developers. I’ve been using it as a context vault for everything I’m building & writing…NOT just code.
Outlines, characters, research all alive between sessions. No more context rot or pasting large chuncks of writing into a small prompt window that’s forgotten 5 minutes later.
Honestly here is just a short list of things you can do with Cursor: • ✍️ Write your 100-page novel with a dedicated assistant who already knows your plot, characters, tone. • 📊 Build strategy decks where every amendment, every critical talking point, is preserved in context. No need to pause and recollect. • 🗂️ Manage research & knowledge bases across topics. Weeks later, your AI will remember what you meant by “Plan A vs Plan B.” • 🎮 My personal favorite – Design systems, games, products with shared reference docs so changes in one place reflect everywhere.
Here’s a VERY quick 2-step “how to start your novel, research, or even a PRD with really solid context”: 1. Create your reference docs in Cursor (traditionally that’s a “Claude.md”. • Include references to Character sheets: who people are, what their motives are • World / setting / tone doc: what style you’re going for, key rules • Plot outline: high-level beats 2. Instantiate your AI assistant using those docs as preloaded context • When you prompt, include reference links or identifiers rather than re-stating everything • As you write, update the docs in Cursor and let the assistant refer back. Treat it like shared memory
If you like thinking about how we can make communication easier with AI. Check out my “Designed to Be Understood” series where I explore this stuff in depth.
🌐 Official Site: walterreid.com – Walter Reid’s full archive and portfolio
Every other day I see the same post: 👉 “Google, Harvard, and Microsoft are offering FREE AI courses.”
And every day I think: do we really need the 37th recycled list?
So instead of just pasting another one… I decided to “write” the ultimate prompt that anyone can use to make their own viral “Free AI Courses” post. 🧩
⚡ So… Here’s the Prompt (Copy -> Paste -> Flex):
⸻
You are writing a LinkedIn post that intentionally acknowledges the recycled nature of “Free AI Courses” list posts, but still delivers a genuinely useful, ultimate free AI learning guide.
Tone: Self-aware, slightly humorous, but still authoritative. Heavy on a the emoji use. Structure: 1. Hook — wink at the sameness of these posts. 2. Meta transition — admit you asked AI to cut through the noise. 3. Numbered list — 7–9 resources, each with: • Course name + source • What you’ll learn • How to access it for free 4. Mix big names + under-the-radar gems. 5. Closing — light joke + “What did I miss?” CTA.
Addendum: Expand to as many free AI/ML courses as LinkedIn’s 3,000-character limit will allow, grouped into Foundations / Intermediate / Advanced / Ethics.
⸻
💡 Translation: I’m not just tossing you another recycled list. I’m giving you the playbook for making one that feels fresh, funny, and actually useful. That’s the real power of AI—forcing everyone here to raise their game.
So take it, run it, grab a few free courses—and know you didn’t need someone else’s output to do it for you.
💪 Build authority by sharing what you learn. 🧠 Use AI for the grunt work so you can focus on insight. 💸 Save time, look smart, maybe even go viral while you’re at it.
⸻
🚀 And because I know people want the output itself… here’s a starter pack: 1. CS50’s Intro to AI with Python (Harvard) – Hands-on projects covering search, optimization, and ML basics. Free via edX (audit mode). 👉 cs50.harvard.edu/ai 2. Elements of AI (Univ. of Helsinki) – Friendly intro to AI concepts, no code required. 👉 elementsofai.com 3. Google ML Crash Course – Quick, interactive ML basics with TensorFlow. 👉 https://lnkd.in/eNTdD9Fm 4. fast.ai Practical Deep Learning – Build deep learning models fast. 👉 course.fast.ai 5. DeepMind x UCL Reinforcement Learning – The classic lectures by David Silver. 👉 davidsilver.uk/teaching
Happy weekend everyone!
🌐 Official Site: walterreid.com – Walter Reid’s full archive and portfolio
…Or how I learned to stop vibe-coding and love the modular bomb
Honestly, it’s been a while.
Like many of you, I’ve been deep in the weeds — testing AI limits, hitting context walls, and rediscovering that the very thing that makes AI development powerful (context) is also what makes it fragile.
A recent — and increasingly common — Reddit thread snapped it into focus. The developer cycle looks like this:
Vibe-code → context fades → docs bloat → token limits hit → modular fixes → more docs → repeat.
It’s not just annoying. It’s systemic. If you’re building with AI tools like Claude, Cursor, or Copilot, this “context rot” is the quiet killer of momentum, accuracy, and scalability.
The Real Problem: Context Rot and Architectural Drift
“Vibe-coding”—the joyful chaos of just diving in—works at small scale. But as projects grow, LLMs choke on sprawling histories. They forget relationships, misapply logic, and start reinventing what you already built.
Three things make this worse:
LLM Degradation at Scale: Chroma’s “Context Rot” study and benchmarks like LongICLBench confirm what we’ve all felt: as context length increases, performance falls. Even models like Gemini 1.5 Pro (with a 1M-token window) start stumbling over long-form reasoning.
Human Churn: Our own docs spiral out of date. We iterate fast and forget to anchor intent. .prod.main.final.final-v2 is funny the first time it happens… just not the 27th time at 2 am with a deadline.
Architectural Blindness: LLMs are excellent implementers but poor architects. Without modular framing or persistent context, they flail. As one dev put it: “Claude’s like a junior with infinite typing speed and no memory. You still need to be the brain.”
How I Navigated the Cycle: From Chaos to Clauses
I’m a business and product architect, but I often end up wearing every hat — producer, game designer, systems thinker, and yes, sometimes even the game dev. I love working on game projects because they force clarity. They’re brutally honest. Any design flaw? You’ll feel it fast.
One night, deep into a procedural, atmospheric roguelite I was building to sharpen my thinking, I hit the same wall every AI-assisted developer eventually crashes into: context disappeared, re-prompts started failing, and the output drifted hard. My AI companion turned into a bit of a wildcard — spawning new files, reinventing functions, even retrying ideas we’d already ruled out for good reason.
Early on, I followed the path many developers are now embracing:
Start vibe-coding
Lose context
Create a single architectural document (e.g., claude.md)
That bloats
Break it into modular prompt files (e.g., claude.md, /command modules/)
That eventually bloats too
The cycle doesn’t end. It just upgrades. But each step forward buys clarity—and that’s what makes this process worth it.
claude.md: Not My Invention, But a Damn Good Habit
I didn’t invent claude.md. It’s a community practice—a persistent markdown file that functions like a screenplay for your workspace. You can use any document format that helps your AI stay anchored. The name is just shorthand for a living architectural spec.
# claude.md
> Persistent context for Claude/Cursor. Keep open during sessions.
## Project Overview
- **Name**: Dreamscape
- **Engine**: Unity 2022+
- **Core Loop**: Dreamlike exploration with modular storytelling
## Key Scripts
- `GameManager.cs`: Handles global state
- `EffectRegistry.cs`: Connects power-ups and logic
- `SceneLoader.cs`: Transitions with async logic
TIP: Reference this in prompts: // See claude.md
But even this anchor file bloats over time—which is where modular prompt definitions come in.
claude.md + Module files: Teaching Commands Like Functions
My architecture evolved. I needed a way to scope instructions—to teach the AI how to handle repeated requests, like creating new weapon effects or enemy logic. So I made a modular pattern using claude.md + command prompts:
# claude.md
## /create_effect
> Creates a new status effect for the roguelike.
- Inherits from `BaseEffect`
- Registers in `EffectRegistry.cs`
- Sample: `/create_effect BurnEffect that does damage over time`
This triggers the AI to pull a scoped module file:
# create_effect.module.md
## Create New Effect
1. Generate `PoisonEffect.cs` inheriting from `BaseEffect`
2. Override `ApplyEffect()`
- Reduce enemy HP over time
- Slow movement for 3s
3. Register in `EffectRegistry.cs`
4. Add icon: `poison_icon.png` in `Resources/`
5. Update `PlayerBullet.cs` to attach effect
The AI now acts with purpose, not guesswork. But here’s the truth: Even modularity has entropy. After 20 modules, you’ll need sub-modules. After that, indexing. The bloat shifts—not vanishes.
Modularity Is Just the Next Plateau
The Reddit conversations reflect it clearly—this is an iterative struggle:
Vibe-coding is fast, until it fragments.
Documentation helps, until it balloons.
Modularity is clean, until it multiplies.
So don’t look for a silver bullet. Look for altitude.
Every level of architectural thinking gets you further before collapse. You’re not defeating context entropy—you’re just outpacing it.
Actionable Takeaways for Technical Leaders
Design Before Code: Start every feature with a plain-English .md file. Force clarity before implementation.
Modularize Prompt Context: Keep a /prompts/ directory of modular markdown files. Load only what’s needed per task.
Feature-by-Feature Git Discipline: Develop in small branches. Commit early, often. Update specs with every change.
Own the Architecture: LLMs build well—but only from your blueprints. Don’t delegate the structure.
Bonus: Based on my tests for token usage this method reduces prompt size by 2–10x and cuts debugging time by up to 25% because it introduces more surgical precision.
This Will Happen to You — and That’s the Point
If you’re building anything complex—a game system, a CRM, a finance tool—this will happen to you. This isn’t hyperbole. It will.
Not because your AI model is weak. But because the problem isn’t model size—it’s architectural load. Even with 2 million tokens of context, you can’t brute force clarity. You have to design for it.
That’s why I believe the era of AI-assisted development isn’t about being better developers. It’s about becoming better architects.
What’s Your Approach?
How are you managing AI context in real projects? Have a prompt ritual, toolchain trick, or mental model that works? Drop it in the comments. I’m collecting patterns.
Sources:
Chroma Research – Context Rot: How Increasing Input Tokens Impacts LLM Performance
Description: A research paper defining and demonstrating “Context Rot,” where LLM performance degrades significantly with increasing input context length across various models.
LongICLBench: Long-context LLMs Struggle with Long In-context Learning – arXiv
Description: Google’s explanation of long context windows, including Gemini 1.5 Pro’s 1 million token capacity and internal research on even larger contexts.
Prompt Engineering in Esperanto? Quite possibly yes! So, I gave DALL·E the same prompt in English, Esperanto, and Mandarin (written in Simplified Chinese).
The Esperanto and Mandarin versions got Santa’s face right. The English version added a hat I never asked for.
Why? Because Esperanto and Mandarin don’t carry the same cultural defaults. It says what it means. English… suggests what you probably meant.
Sometimes the clearest way to talk to an AI is to ditch the language it was trained on.
I’ve started calling this the “Esperanto Effect”: “When using a less ambiguous, more neutral language produces a more accurate AI response.”
Makes you wonder… what else are we mistranslating into our own tools? 🤖 Curious to test more languages (Turkish? Latin?) 🎅 Bonus: I now have a Santa that looks like Morpheus — minus the unnecessary hat.
