How to Explore How Problems Were Solved Historically (Be Creative)

Creativity looks like magic at a distance, and like good bookkeeping up close. We manage inputs, then we reconcile them into a form we can spend. Historical analogies give us inputs with a bonus: they carry tested constraints. By definition, someone already ran into the rock and built the detour. The speed we gain is not in stealing answers, but in skipping a few blind alleys.

The literature is unromantic about this. In the classic “radiation problem” studies by Gick and Holyoak, only about 10–30% of participants solved a hard problem cold. When given a structurally similar story (a general dividing troops to avoid mines), solution rates jumped toward 70–92%—but only if participants were cued to use the analogy. Without the cue, many still failed, staring at the surface mismatch: hospitals are not battlefields. The lesson for us is blunt. If we want the transfer, we must build the cue ourselves: a short mapping step to force structure over surface.

The costs are also real. If we search too broadly, the time evaporates. If we pick analogies too close to our field, we import the same blind spots. And if we treat history as authority, we may ignore context and scale. The antidote is modest: we set a timer, we pick a variety (one near-domain, one far-domain), and we summarize the pattern in function words rather than nouns. For example: “divide load into small parallel streams to reduce peak strain,” not “use multiple ambulances.”

We will make one explicit pivot in this piece to model how we adapt midstream:

• We assumed we needed the perfect historical match → we observed it took 40+ minutes to find one and we felt our energy drop → we changed to a constraint-first search (filter by resource, risk, and throughput) and found usable analogies in 8–12 minutes.

Hold that shape in mind. It will save us when we start to drown in bookmarks.

We have a real problem. Say we lead a team that must onboard 120 new users to a tool in two weeks with minimal support hours. We have three constraints: a hard deadline (10 business days), scarce expert time (3 hours per day across two people), and failure risk (users who struggle may churn). We feel that familiar pressure: we could write two new guides, maybe record a video, maybe run a webinar. But we also feel that this is the same structure as many past problems: moving many novice agents through a fragile process without breaking anything.

We open a notebook and write our three constraints in simple terms:

• Throughput target: 120 completions by Day 10
• Scarce expert availability: 360 minutes/day total
• Fragility points: install step, permissions, first data import

We set a timer for 25 minutes. We write “history analogies” at the top margin. We will try to find three patterns from different contexts: one near (software onboarding), one far (public health vaccination drives with limited nurses), and one odd (postal systems training temporary holiday workers). If we do not find three, we will settle for two and move on. The timer is part of the practice. Without it, we drift.

We do not expect the perfect match. We want the shape of a solution under constraints like ours. If we get the shape, we can build the specific move after lunch.

We search for “historical vaccination campaign throughput constraints nurse hours” and “postal seasonal workers training throughput 1930s” and “software onboarding cohorts triage history.” We skim. A 1950s smallpox vaccination memo mentions “ring vaccination” as a strategy when vaccine and staff are limited: focus on contacts of known cases, not the whole population. A postal history case mentions “bundle sort” and “route templating” to let temporary workers perform with lower error by reducing degrees of freedom. In a 2008 startup case study (not old, but older), we find “30–60–90 minute cohort sessions with prework checklist,” reducing one-on-one time by 65%.

We feel the tug to dive deeper. The timer says 18 minutes left. We force the mapping. We write three pattern cards with the same headings for each:

• Name the pattern in function words
• Inputs required (people, tools, time)
• What it prevents (failure mode)
• What it costs (what we give up)
• A concrete move we could try today

We keep each to 4–6 lines, not because brevity is noble, but because the clock is real. Our afternoon will judge us, not our bibliography.

Pattern card 1 — “Ring focus under scarcity”

• Function: prioritize based on risk proximity to reduce spread of failure.
• Inputs: live signal of who is at risk (help request, stalled event), triage rule.
• Prevents: wasting time on users who would succeed without help.
• Costs: some users wait; risk of missing silent strugglers.
• Move: instrument “stalled >24h at install” and “import error >2” as triggers; offer 15-minute “rescue” slots first.

Pattern card 2 — “Route templating and bundle sort”

• Function: reduce degrees of freedom by giving preset sequences that lower cognitive load.
• Inputs: fixed templates, visual checklists, simple error detection.
• Prevents: novice paralysis and drift.
• Costs: less customization, potential friction for edge cases.
• Move: publish 3 preset onboarding routes (solo analyst, small team, large team) with a one-page checklist.

Pattern card 3 — “Cohort sessions with prework”

• Function: amortize expert time across many learners after shifting basic work to pre-session.
• Inputs: prework materials (10-minute video), signup slots, group chat for Q&A.
• Prevents: repetitive one-on-one explanations.
• Costs: less personalized pacing, scheduling overhead.
• Move: two daily 30-minute cohort sessions with mandatory prewatch of an 8-minute setup video.

We pause. The timer says 8 minutes left. We want one more far analog to challenge our assumptions. We think of medieval guild apprenticeships, but the resource mix is wrong. We think of WWII pilot training innovations—use simulators to practice critical steps. That yields a “safe micro-practice before real flight” pattern.

Pattern card 4 — “Simulate critical step safely”

• Function: practice the riskiest move in a low-stakes environment.
• Inputs: sandbox or demo data, reset button.
• Prevents: fear-induced avoidance, catastrophic first mistakes.
• Costs: building the sandbox; time to reset.
• Move: provide a “mock dataset import” that takes 3 minutes and can be undone instantly.

We close the search with 3 minutes remaining. We are slightly annoyed—we wanted to read more—but also relieved. We have four cards. Our problem feels less foggy.

Mini-App Nudge: In Brali LifeOS, add “History Model Card” as a template with the five headings above. One tap clones it for new problems.

We have the pattern cards. Now the question is: what can we schedule before lunch? We pull up the calendar. We could move the two expert slots to cohort sessions and write the two-page checklist. But the checklist might take an hour. The cohort slots we can create in 6 minutes, but only if we accept simple branding. The sandbox import will take engineering help—unlikely today.

Trade-offs on the table:

• Cohorts are a fast change with high leverage, but they depend on prework being clear.
• The “ring focus” requires instrumentation—do we have an event for “import error >2”? We can approximate with support ticket tags now, then add proper events later.
• Route templating (checklist) is the most durable, but we cannot do a polished version in 20 minutes. We can do a plain text starter.

We decide to do the smallest viable version of each:

• Post two cohort sessions with a basic description; record a quick 8-minute video with one take, no editing. That is 12 minutes to record and upload if we do not fuss.
• Create a 1-page route template in plain text for “solo analyst” with 7 steps. No images. That is 15 minutes.
• Add a temporary triage rule by instructing support to tag “install-stuck” and “import-error” and route them to the cohort invite. That is 5 minutes.

We assume the plain text will be “too ugly to use” → we observe that people in our Slack channel care about clarity, not polish → we change to a text-first doc with bolded step numbers, promise to add screenshots tonight. This is our small pivot. It keeps momentum.

By 12:35, we could have:

• Two cohort slots on the calendar (30 minutes each at 15:30 and 17:00)
• A simple 8-minute prewatch video
• A text checklist with 7 numbered steps
• A support tag rule posted in the team channel

We aim for done, not elegant. The analogies earn their keep if we ship something before lunch.

We can generalize this micro-scene into a repeatable habit. It has four moves:

1. Frame the constraints in function terms (time, risk, throughput).
2. Pull 2–3 historical patterns from diverse contexts, time-boxed to 25 minutes.
3. Write pattern cards in function words with a concrete move we can try today.
4. Commit one move to the calendar within the next 3 hours.

If we do this three times a week, the compounding effect is real. We generate 6–9 pattern cards per week, and even if only 30% produce a useful move, we ship two changes weekly that we were not shipping before. It is a modest bet with a clear metric.

The cognitive trick is to always name the function. When we say “ring focus under scarcity” instead of “smallpox strategy,” we make it transportable. When we say “route templating” instead of “postal bundle sort,” we see where else it can fit—sales demos, lab protocols, onboarding sequences, even a morning routine with kids.

The web is a tidal river. We will be swept if we wade in unanchored. Our anchors are:

• A fixed time window (e.g., 25 minutes).
• A target mix: one near-domain, one far-domain, one oddball.
• A constraint-first query: include words like “scarcity,” “throughput,” “error,” “fragility,” “triage,” “queue,” “parallel,” “decompose,” “buffer,” “feedback,” “permission.”

Instead of “history of onboarding,” we type “history queue triage under scarcity hospital admissions 1950s,” or “postal route optimization training temporary workers error reduction,” or “assembly line introduce new step ramp time.” We are not trying to be scholars; we are trying to meet a deadline. If we land on a Wikipedia page, we scroll to the section where a constraint is named. If we land on a memoir, we skim for decisions, not motives.

We keep a notebook page titled “search traces.” We write the three best queries and what they yielded. This is not busywork. If we need to repeat this for a new problem next week, the traces save us 5–10 minutes. Over a month, that is an hour recovered.

We also impose a one-tab rule during the first 10 minutes: we do not open a new tab until we finish one pattern card sentence. It keeps us from hoarding raw material we never cook.

There is a crisp failure mode. We fall in love with an analogy that has a noble story (Apollo 13 improvisation, Bletchley Park codebreaking) and we force-fit it to our much smaller problem. The danger is not just embarrassment. It is the false confidence from a story that carries status rather than structure.

Safeguards we can actually use:

• Write the costs explicitly on the pattern card. If the story’s hero had infinite skilled labor, and we do not, the costs line will sting.
• Check the scale mismatch. If their solution assumed thousands of instances per hour and we have 12 per day, the queueing regime may flip. In that case, a batch process might increase delay variance, not reduce it.
• Force an A/B of nuance. Try the analogy move in one small segment (e.g., new users from one channel) before applying it globally. If we cannot isolate even a tiny test, the analogy is probably too heavy.

We also challenge ourselves to collect counter-analogies. If we found “ring focus” from public health, we also look for a case where prioritization created blind spots (e.g., ignoring silent carriers). That keeps us from over-fitting. We are not moralizing. We are just hedging against the usual human bias.

We assumed our best analogies would come from “impressive” domains (space, war, medicine)
→ we observed that those took longer to find and often carried constraints we did not share (huge budgets, national urgency) → we changed to a constraint-first eclecticism: we search for function words and accept humble sources (postal training, municipal water systems, school cafeterias). The quality of usable patterns rose, and the time to first card fell from ~40 minutes to ~12–18 minutes per session. Our ego was offended at first; our calendar was grateful.

To be sure this is not tied to onboarding, we run the same method on a different problem. We have a two-day design sprint. Day one produced generic ideas. The team feels flat. We need a way to provoke novelty without chaos, and we have only 90 minutes before the concept selection.

Constraints:

• Time: 90 minutes
• Risk: losing focus, fragmenting the team
• Throughput: generate 20–30 candidate variations quickly

Historical analogies we search for:

• “Constrained creativity methods history composer forms”
• “Industrial design variation generation Toyota set-based design”
• “Renaissance painting workshops variations under patron constraints”

Pattern card A — “Set-based design”

• Function: explore multiple design sets in parallel, narrowing by eliminating dominated options rather than picking one early.
• Inputs: quick criteria, cheap artifacts, time-boxed rounds.
• Prevents: premature convergence.
• Costs: requires discipline; may feel wasteful.
• Move: run two 15-minute rounds where each person sketches three variants; eliminate by criteria (cost, time) rather than voting on favorites.

Pattern card B — “Canon with inversion (composers’ trick)”

• Function: generate novelty by applying structural transformations (invert, retrograde, augment) to a base theme.
• Inputs: a base design, transformation rules.
• Prevents: blank-page paralysis.
• Costs: may produce gimmicky outputs if used slavishly.
• Move: choose the most boring idea, then force three transformations: inverse hierarchy (swap primary/secondary features), time-scale (compress steps), and negative space (remove the core and let context carry it).

Pattern card C — “Workshop apprentice variations”

• Function: produce controlled variation by delegating to multiple hands with a common template and letting local interpretation add texture.
• Inputs: clear template, fixed constraints, small freedoms.
• Prevents: full divergence.
• Costs: some unevenness; requires template quality.
• Move: distribute a base wireframe to four people; let each change only typography and spacing to see how tone shifts; collect learnings.

We schedule a 60-minute block: 2 x 15-minute generation rounds (using transformations), 15 minutes to eliminate by criteria (set-based elimination), 15 minutes to recombine. We measure output: number of variations (target 24), and we capture at least three “why” notes per elimination. The analogies give us the skeleton of the session. We will not claim genius. We will claim structure. It is enough to unstick a room.

We are not doing research; we are building a habit. We need two numbers we can write down without thinking:

• Minutes spent on historical analogies today
• Analogies captured (count of pattern cards with a concrete move)

We might add “moves scheduled” as a third number, but we can infer it from the calendar. In Brali LifeOS, the “History Analogies” module logs:

• Minutes: 0–60 (we target 20–30 most days; 10 on busy days)
• Count: 0–5 pattern cards (we target 2–3) We keep a weekly aim: 60 minutes total, 6+ pattern cards, 2+ moves shipped.

This is not sacred. It is scaffolding. The numbers keep us honest when our brain insists “we had a very creative week” while our calendar shows no artifacts.

Sample Day Tally (aim: 30 minutes, 3 pattern cards)

• 08:45–08:55: Search + card 1 (postal bundle sort → route templating)
• 08:55–09:05: Search + card 2 (ring focus under scarcity)
• 09:05–09:15: Search + card 3 (cohort prework amortization) Totals: 30 minutes, 3 cards, 1 move scheduled (cohort sessions at 15:30). We log “30 min, 3 cards” in Brali.

The tally is humble by design. We can do it between calls.

• If our domain is highly regulated (medicine, aviation), historical analogies cannot override compliance. We filter moves through safety and policy. We can still use the pattern to structure safer experiments (e.g., simulate the critical step, add a buffer queue).
• If we are new to a field, we may misread constraints in history. To mitigate, we ask one domain expert to sanity-check our pattern card. A 3-minute message can save a day.
• If we lack time even for 10 minutes, we do the busy-day alternative path (below).
• If our team resists “history talk,” we avoid grand stories. We present a 3-line pattern and a concrete small move. We let results sell it. Most teams respond to a graph, not a Churchill quote.
• If English is not our first language or we have limited access to certain sources, we rely on function words that translate well and use local histories (municipal reports, trade manuals). The pattern language travels; the nouns do not have to.

Risks and limits:

• Confirmation bias: we may cherry-pick cases that justify what we already want to do. The counter is to write one “anti-pattern” per session: a case where a tempting move failed. Even a single sentence helps.
• Overfitting: a pattern seen once may not generalize. We treat each card as a hypothesis, not doctrine.
• Cost creep: we get excited and try to implement the heavy version (beautiful checklist, full sandbox) immediately. We force ourselves to ship a light version first, then iterate.

It is 09:42. We have a cup of coffee we forgot to drink. We face the tiny dread of hitting record for the 8-minute prewatch video. We think of the composer analogy. We decide to record a first take using the “augmentation” trick—slow down the parts that often confuse people. We add 15 seconds where we highlight a button. We leave our stammers in. We upload. The relief is not heroic; it is small and useful.

It is 12:50. A teammate pings: “The plain text checklist is ugly.” We feel a flare of embarrassment. We remind ourselves the postal workers learned with black-and-white typed route sheets. Function over form, for now. We reply: “Agree. I’ll add screenshots tonight. For now, please try it with your 13:00 call?” They do. The user completes step 4 without asking for help. It is enough to justify the friction.

It is Thursday. Our weekly log says 62 minutes, 7 cards, 2 moves shipped. Not bad. The cohort sessions had 18 and 21 attendees; support tickets dropped from 42 to 29 per day (–31%) on days with sessions. We did not solve everything. The sandbox import is still not built. But the analogies translated to two concrete moves, both shipped. We feel the non-exciting satisfaction of a habit that is starting to pay.

The creativity category often sounds like pure work. But the same method fits life logistics. We want to reduce weekday cooking stress with limited evening energy (45 minutes, two adults, two children). Historical patterns: wartime rationing cookbooks (batch base + variable topping), monastic meal bells (fixed time windows), Tiffin carriers in Mumbai (stacked modular meals). Pattern cards emerge:

• “Base + variable” (cook 1 kg of a base grain on Sunday; vary toppings to create novelty).
• “Fixed slots” (eat at 18:30 with a 30-minute prep limit).
• “Stacked carriers” (prep lunch boxes the night before in layers).

We schedule Sunday: 40 minutes to cook 1 kg rice (dry), portion into four containers of 250 g cooked weight per meal; we write two topping ideas with specific grams (e.g., 150 g chickpeas, 80 g sautéed greens). We feel less romantic and more calm. Creativity shows up as hot food on the table with predictable effort.

We mention this because the muscle we are building does not care which domain it lifts. It cares that we move from history to pattern to small move to calendar. If we can do it for dinner, we can do it for onboarding.

We resist turning this into a Notion cathedral. The smallest useful library is a folder with 20–40 pattern cards over two months. Each card is a half page. We tag lightly: [queue], [triage], [scaffold], [parallel], [buffer], [simulation]. When a new problem arrives, we glance at the tag folder. We do not search the whole web again; we pull one old card and one new from the net. That combination—one known, one fresh—gives us speed and novelty.

We reserve 15 minutes on Friday to prune. Delete cards that never yielded a move. Merge near-duplicates. Add one sentence noting where a pattern failed. It is the opposite of hoarding. It keeps our small library alive and light.

In Brali LifeOS, this is literally a journal with tags. We add a “Pattern Card” template. We log minutes and count, once per day. The app keeps the weekly sum so we do not have to.

• Set a recurring 25-minute block three times a week with a name that makes sense to future-you: “History Analogies — [Today’s Problem].”
• Write the problem’s constraints first. If we skip this, we read aimlessly.
• Start with one far-domain search term in the first 5 minutes. It shakes loose our default.
• Write costs. If a pattern has no cost, we probably do not understand it.
• Push one move to the calendar within 3 hours. Momentum is a brittle asset; spend it while it exists.

After a while, the personal cues become muscle memory. We feel the itch to name function over form. We hear ourselves say “What is the smallest safe sandbox we can build?” and realize we just echoed a wartime pilot trainer without the drama.

• “History means old and irrelevant.” No. We are not copying logistics carts. We are copying “decouple fragile step with a buffer,” which is timeless.
• “We need to be experts in that domain.” No. We need to extract function words and one structural move. Respect the domain; steal the skeleton.
• “This will take too long.” For the first week, it feels slow (25 minutes for two cards). By week two, we hit three cards in 20 minutes. The expected return is about one usable move per session. If we cannot spare 20 minutes twice a week, we have a bigger problem than creativity.
• “We will lose originality.” Ironically, borrowing structure prevents cliché. Most cliché comes from local defaults. Far analogies inject new defaults we would not have invented.

It will. We will apply “ring focus” and miss the silent strugglers. We will learn. The correction is also patterned: add a “silent signal” such as a passive metric (no activity after 72 hours) and route those to an asynchronous help artifact. The costs: we contact some people who do not need help; we risk annoyance. We measure opt-out rate. If it is under 5%, we keep it.

The point is not to argue for the pattern. It is to argue with it and adjust. The habit persists through small recoveries.

We assumed everyone would complete the 8-minute prewatch video before cohort sessions → we observed 38% of attendees had not → we changed to starting each session with a 3-minute “compressed prewatch” recap, plus we added a checkbox in the signup form. Attendance stayed high; completion improved to 77% by week two. The analogy here is from “preflight checklists”—do not assume; verify quickly. We quietly borrowed safety thinking without ceremony.

When the day is packed:

• Write the problem and one constraint in 1 minute.
• Open one trusted source (e.g., Wikipedia list of queueing disciplines, or a specific historical memo we know).
• Capture one pattern in three lines with one concrete move.
• Schedule a 15-minute test this week.

That is it. Five minutes. One card. It keeps the streak and it keeps the mind oriented to structure over noise.

In two weeks of light practice:

• Sessions: 6 (3 per week)
• Minutes: 132
• Pattern cards: 15
• Moves shipped: 5
• Observable outcome: onboarding tickets –24% (from 40/day to 30/day average), time-to-first-success down from 3.2 days to 2.1 days.

We are careful not to over-attribute. Other changes happened. But even a partial contribution justifies 132 minutes. Our skeptical future self appreciates a concrete ratio: ~26 minutes per shipped move, which is efficient.

Good enough is three characteristics:

• The pattern is named in function language.
• The costs are explicit.
• The move is scheduled today.

Perfect would be annotated quotes and a small diagram. We rarely need it. We reserve that for patterns we reuse across months (e.g., “parallelize feedback early” became a staple for us; we invested in a nicer artifact).

We catch ourselves saying, “This feels like a triage problem under scarcity,” and notice our team shifts posture from debate to design. We see a whiteboard with a column labeled “buffers.” Someone circles “5-minute preflight checklist for webinar” and we remember reading about 1930s airmail pilots and their checklists. A junior teammate posts a pattern card sourced from a coffee roaster’s blog about batch size and cooling time; we use it to adjust our content batching. We smile. The habit spread without fanfare.

• Do not turn the library into a status object. The goal is shipping moves, not collecting cards.
• Do not hide the costs. Team trust erodes when we present patterns as magic bullets.
• Do not let the session slip past 30 minutes unless we are shipping today. Depth is for Saturday mornings or formal research, not the Tuesday crunch.

We allow a little emotion in this. Relief when a pattern gives us traction; frustration when a late meeting cancels our planned session; curiosity when an oddball analogy (beaver dams as distributed buffers) unlocks a product architecture conversation. We do not perform inspiration. We acknowledge the warm, quiet pleasure of using someone else’s hard-won lesson with respect. We feel part of a longer line of problem-solvers. It is a good feeling, and it lasts longer than a “motivation hack.”

• Did I spend at least 10 minutes extracting 1–3 historical patterns for a live problem today?
• Which concrete move did I schedule on my calendar, and for when?
• What sensation dominated during the session—clarity, confusion, or drift? (pick one)

• How many pattern cards did I create this week, and how many moves shipped?
• Which analogy produced the most impact, and what cost did we accept to make it work?
• Where did an analogy mislead us, and what constraint did we miss?

• Count: pattern cards captured today (0–5)
• Minutes: time spent on historical analogies today (0–60)

Goal: Improve our support triage in 30 minutes.

• 07:55–08:05: Search “history telephone switchboard triage rules” → card: “first-failure routing; send to generalist, escalate by decision tree.”
• 08:05–08:15: Search “emergency department fast track low acuity” → card: “fast-track queue for predictable issues; separate flow reduces congestion.”
• 08:15–08:25: Search “airline IRROPS recovery crew pairing” → card: “reserve buffer capacity; hold 10% capacity idle to absorb shocks.” Totals: 30 minutes, 3 cards, move scheduled: add a “fast track” form for common issues, reserve one agent for buffer from 13:00–15:00.

We log 30 min, 3 cards. We feel better walking into the 09:00 standup with a concrete plan, not just anxiety.

In Brali:

• Create a recurring task: “History Analogies — [Problem]” (25 minutes).
• Use the “Pattern Card” journal template with fields: Function, Inputs, Prevents, Costs, Move.
• Log Minutes and Count in the check-in. Brali will chart weekly totals.
• Attach the scheduled calendar move to the task. When the move is done, add a two-line “Result” note (numbers if possible).

We keep it light. The app is a mirror and a nudge, not a boss.

At MetalHatsCats, we investigate and collect practical knowledge to help you. We share it for free, we educate, and we provide tools to apply it. The longer we practice this, the more often we hear our team say, “What’s the pattern here?” and the less often we waste a morning reinventing a wheel shaped like last quarter’s wheel.

Try the Brali “2×2 Analogies” micro-module: it prompts one near-domain and one far-domain pattern card per session and auto-asks for costs. Two taps, two cards.

We do not need permission to learn from the past. We need a timer, a notebook, and the humility to write “costs” alongside “moves.” We choose structure over heroics, function words over fancy nouns, and tiny shipping over grand intentions. We come back tomorrow, and the day after. The work compounds. The sense of agency returns.

We close with a simple path for today:

• Pick one live problem.
• Set 25 minutes.
• Capture two pattern cards and schedule one move.
• Log Minutes and Count.

We will build from there.