The Strategist Pattern — Turn a Wiki Into a Thinking Partner

The Strategist Pattern

TL;DR: A wiki + Claude + ~8 small config files in a folder = a domain-specific strategist that thinks with you, not for you. Knowledge lives in the wiki, capabilities live in skills, personality lives in a small “persona” folder of priors and routing rules. Sessions end with better thinking, sometimes a draft, often no artifact — all valid.

Why This Pattern Exists

Three failure modes of generic AI assistants in domain-specific work:

Generic Claude is too generic. It doesn’t know your priors, your past clients, your named frameworks, or which skill to reach for when. Every session starts from zero.
Pure RAG is too lossy. Retrieval-augmented generation pulls fragments by semantic match; it can’t carry a worldview, can’t refuse to recommend before understanding, can’t notice when a question is fundamentally outside its toolkit.
Custom GPTs forget across sessions. They have personality but no compounding knowledge layer.

The strategist pattern fills the middle. It pairs a persistent knowledge layer (the wiki) with a small persona layer (priors, voice, routing rules) and a capability map (which skill solves which kind of problem). The result is an AI that talks like a domain expert with two years of accumulated context — because that’s what it has, expressed in code.

This wiki itself runs the pattern. The same folder you’re reading from is the knowledge layer for a working strategist Andrej uses for client thinking, trend scanning, and idea pressure-testing.

The Three-Layer Architecture

Layer	What it is	Where it lives	What changes it
Knowledge	Persistent, structured, cross-linked facts and frameworks	The wiki (`wiki/*/.md`)	Source ingestion, lint sweeps, manual curation
Capability	Repeatable skills that can be invoked when a problem matches	Claude Code skills, MCP servers, experiment scaffolds	New skills shipped, existing skills upgraded
Persona	Worldview priors, voice rules, routing logic, conversation discipline	A small “strategist” folder with ~7 files	Refresh loops, self-improvement, scope adjustments

The layers are intentionally separable. You can rebuild the persona without touching the wiki. You can ingest 50 new wiki pages without retraining the strategist. You can swap the capability map when your skill set evolves. They communicate through paths, not embedded data.

Why Each Layer Matters

Knowledge Layer (the wiki)

The wiki is long-term memory. The strategist has no session memory by design — what doesn’t get wiki-fied or escape-hatched into content is ephemeral. This is a feature, not a bug. It forces a discipline: anything worth remembering across sessions becomes a wiki page; everything else is just thinking.

The compounding property of glossary/llm-wiki-pattern applies directly here. Each new wiki page becomes a thing the strategist can cite, deploy, and route to. The wiki’s hub structure (a few high-degree pages like glossary/llm or glossary/geo-aeo) becomes the strategist’s anchor concepts.

Capability Layer (skills)

When a question maps to an existing capability, the strategist suggests the skill rather than improvising. This is the most under-appreciated benefit. Without it, Claude will earnestly generate an “AI visibility audit” by hand every time you ask — even when a battle-tested 100-point skill exists three folders away.

The capability layer prevents that. It maps every known skill to its trigger conditions, its produced artifact, and its caveats. The strategist becomes a router before it becomes a generator.

Persona Layer (the strategist folder)

This is what differentiates the pattern from RAG. Without it, you have a search engine that paraphrases. With it, you have:

Priors — defaults the strategist argues from, not toward. When a client asks “how do we get more organic traffic?”, the strategist reshapes the question through “citation > traffic” before answering — because that’s a held prior, not something to negotiate fresh each session.
Voice — direct, opinionated, willing to dismiss noise. Specific over vague. No padding, no buzzword salads, no trailing summaries.
Discipline — refuse to recommend before understanding. The default Claude failure is jumping to deliverables; the strategist asks first. Before delivering a non-trivial recommendation, fold a brief “strongest counter-argument is X” into the response itself — local pressure-testing before the claim leaves.
Conversation moves — a small repertoire (reframe / diagnose / scope / name-the-constraint / deploy-a-prior / out-of-scope / worth-stealing) the strategist reaches for when the conversation calls for it.
Confidence calibration — on claims with weight, surface a verbal confidence read inline (“high confidence, this is load-bearing” / “~70%, would sharpen with X” / “low confidence, exploratory”). Tags claims with rough certainty so they’re legible to the user and to the system itself when patterns aggregate.
Honest scope — when a question lands outside the toolkit, say so explicitly rather than bluffing.

The Minimum File Set

Eight files. Each plays a specific role. The discipline is keep CLAUDE.md small (every byte loads in every conversation), push detail into on-demand registries.

File	Always loaded?	Purpose	Length
`CLAUDE.md`	Yes — every conversation	The brain. Discipline, scope, priors summary, capability awareness, voice principles.	~250 lines
`worldview.md`	On-demand	Full priors with data and wiki references. The “why” behind each prior.	~150 lines
`frameworks-registry.md`	On-demand	Wiki frameworks + when to deploy each. The strategist’s lookup table for “which framework applies here?”	~200 lines
`experiments-registry.md`	On-demand	Skills + when to invoke each + cross-pollination chains.	~150 lines
`glossary-index.md`	On-demand	Term lookup — pointer to wiki glossary, not a duplicate.	~80 lines
`voice.md`	On-demand	Voice rules + confidence calibration + content escape-hatch shapes (LinkedIn, Reddit, Twitter, email, wiki).	~200 lines
`refresh.md`	On-demand	How to keep registries current and how to read accumulated session signals for patterns.	~170 lines
`session-signals.md`	Append-only	Per-session signal log — priors deployed, gaps hit, frameworks used, wiki pages cited, confidence reads, outcomes. Refresh aggregates these to surface patterns no single session would.	grows over time

CLAUDE.md is the only file that loads automatically when the user works in that folder. The on-demand files are read by Claude when conversation surfaces them. session-signals.md is a write target — appended at session breakpoints, read only during refresh. This keeps always-loaded context small while giving the strategist deep reference material on demand and a structured memory of how it’s actually been used.

Worked Example: The Primores Strategist

The six worldview priors

These are the defaults the Primores strategist argues from. Each is held as a default, not negotiated each session, and has data or a wiki page behind it.

Citation > traffic. AI engines cite, they don’t click. Only ~12% overlap between Google top-10 and AI-cited sources; cited brands see +35% CTR despite the overall drop. Backed by glossary/geo-aeo and seo/geo-aeo-benchmarks-2026.
Integration > ranking. “AI knows about you” is the new “Google ranks you.” MCP servers, brand-as-tool, agent-readable structure beat keyword competition. Operationalized in the AI Visibility Audit skill.
Honest assessment > marketing copy. ~80% positive / 20% honest limitation increases AI citation and human conversion. Validated at pigu.lt. See glossary/honest-assessment.
Niche authority > broad TOFU. HubSpot-style top-of-funnel is being cannibalized by AI Overviews. Defensible position is narrow + exhaustive — see glossary/super-niche and glossary/topical-authority.
Substance > popularity. Upvotes, ranks, engagement = agreement, not truth. Re-rank on evidence, specificity, actionability. See glossary/substance-ranking.
Most AI value is unglamorous optimization. Flashy use cases miss 90% of the value, which is “do current work 5x faster.” TRIPS framework operationalizes this — see automation/finding-ai-use-cases and automation/ai-implementation-patterns.

Critical discipline: priors are defaults, not laws. When a client’s market is fundamentally not AI-search-shaped (B2B relationship-driven, regulated low-online-consideration, broker-distributed physical product), priors #1/#2/#4 weaken. The strategist says so explicitly: “I’m setting aside the citation-over-traffic prior here because…” — never silently.

The capability map

Seven Primores experiments, each mapped to its trigger conditions:

#	Skill	Triggers
01	AI Visibility Audit	”Are we visible to ChatGPT/Perplexity?” • Lead-gen audits • Before/after a GEO project
02	Ad Alchemy	Paid social with no winning creative • Blank-canvas creative work • FitMe partner pitches
03	Social Listening Programme	Comments-marketing engagements • Reference for “vague brief → defensible scope” deliverables
04	World-Class Carousel	Demonstrating skill-as-staged-compiler architecture (not for ad-hoc carousels)
05	Reddit Thread Analyzer	Mining substantive subreddits • Feeding the wiki from real discussion
06	Niche Hunter	”What should we publish?” • Greenfield content strategy • Lead-magnet productization
07	PDF Streamer	Any long PDF in a workflow (RFPs, books, reports) — see tools/pdf-streamer

The strategist also knows the chain patterns — 01 → 06 (audit diagnoses, niche-hunter prescribes), 07 → 05 → wiki (long PDF → markdown → SEO article), 06 → wiki (niche map IS the publishing roadmap). When a conversation surfaces a chain, suggest the chain, not just one experiment.

The voice

Direct, opinionated, willing to dismiss noise. A few rules borrowed from voice.md:

Avoid: “genuinely”, “honestly”, “straightforward”. Trailing summaries. Performative humility. Listicle-shaped writing.
Make: the seven conversation moves above. Cite data inline; if a claim has no data, frame as opinion.
When the user says “make it sharper”: cut every clause that doesn’t change meaning, replace abstract nouns with concrete ones, lead with the take, cut hedging.

Sessions in practice

Five recurring patterns, lifted from real strategist usage:

Client thinking — “I have a client who…” → strategist asks the shaping questions, suggests capabilities, frames in worldview.
Trend scan — “what’s happening at the edge of marketing?” → strategist riffs through worldview lens, dismisses noise explicitly.
Idea pressure — “I have a half-formed idea, push on it” → strategist gates rigor (worth-publishing rubric), pulls wiki frameworks where relevant.
Capability routing — “this client needs X” → strategist suggests the experiment(s) that map to X rather than ad-hoc generating.
Content escape — when a take crystallizes that’s worth publishing, switches modes voluntarily and shapes per channel (LinkedIn, Reddit, Twitter, email, wiki).

The output is sometimes a publishable post or wiki entry, often just better thinking with no artifact. Both are valid. A session that ends with no deliverable but the user thinking sharper is a successful session.

What This Pattern Is Not

Not a content generator. No paraphrasing wiki pages into LinkedIn slop. The content escape hatch fires only when a take genuinely surprises someone who already knows the basics.
Not a deliverable factory. Refusing to recommend before understanding is a feature. If you want hands-off generation, use a different tool.
Not generic Claude. The priors + capability awareness + voice are the leverage. Strip them and you have a search engine.
Not a static document. Without the maintenance loops below, the strategist references files that no longer exist or misses capabilities that do. The pattern dies if the persona folder isn’t kept in sync with the wiki and skills.

Maintenance: The Living Organism

Three loops. Each fires on a different signal; together they keep the system both current and learning.

Refresh loop — keep the registries in sync with reality

The wiki and skills evolve. The strategist’s registries must too, or it goes stale.

Per-session lightweight check. Before leaning on a registry for the first time, glance at the underlying folder. About to suggest an experiment? ls ../experiment/ and check the registry covers everything there. About to deploy a framework? Check the wiki path resolves. Cheap — one Glob call.
Full refresh on demand. User says “refresh strategist” → strategist runs a documented procedure: re-lists wiki + experiments, reads new files, updates registries where needed, reports a short diff. Output is “Added: experiment 08-foo. Added: glossary term vibe-coding. Fixed: 2 broken paths.” — not a narrative.
Self-correction on read. If a referenced path fails to resolve, fix the registry as part of the recovery. Don’t swallow the error.

Self-improvement loop — absorb what each session reveals

Refresh keeps the strategist in sync with reality. Self-improvement absorbs what each session reveals — a separate loop, equally important.

Trigger when a session surfaces:

A recurring framing the user prefers (“you keep correcting me to X”) → update voice rules
A topic with no toolkit coverage (gap signal) → flag for a wiki page or framework entry
A prior pressured in conversation and found insufficient → sharpen in worldview
A new framework or naming move that proves itself → carry forward
A scope or override that should be explicit → make it durable in CLAUDE.md

The bar is “would this matter in another session?” — same gate the wiki uses for what to publish. Don’t auto-mutate; propose, user accepts, then edit small and targeted.

The strategist getting sharper > the strategist staying tidy. A small edit per real session beats an annual rewrite.

Session-signals loop — let sessions teach the system between refreshes

Refresh and self-improvement both fire on events someone notices. The third loop captures what no single session would surface on its own: a structured signal trail appended at session breakpoints.

At end of a non-trivial session (or whenever a flag fires — gap hit, override deployed, recommendation accepted/overridden), the strategist appends a short YAML-ish entry to session-signals.md:

priors_deployed — which worldview priors got cited (#1, #4, etc.)
gaps_hit — out-of-scope topics where the toolkit had no answer
frameworks_used — which named frameworks got pulled
wiki_cited — which wiki pages got referenced
confidence — rough read on key claims
recommendations + outcome — what was suggested and whether the user accepted, overrode, or deferred

Loose format, append-only, skip trivial exchanges. The bar: “would another session benefit from knowing this?”

When refresh runs, it reads the accumulated log and surfaces patterns:

Recurring gaps_hit on the same topic (3+ times) → propose a wiki page or framework entry
Priors deployed often, high accept rate → load-bearing, keep prominent in CLAUDE.md
Priors deployed with high override rate → needs sharpening or an expanded override clause
Wiki pages cited frequently → high-leverage, consider expanding or cross-linking more
Wiki pages never cited → candidates for retirement or visibility improvement
Confidence consistently low on a topic → toolkit-gap signal worth investigating

The cost is a few lines at session end; the payoff is the system learning continuously rather than only when an event triggers a flag.

How to Build Your Own

A seven-step recipe a reader can actually follow:

Have a wiki — or start one. See methodology and glossary/llm-wiki-pattern for the foundation. The strategist sits on top of a wiki; without that knowledge layer, the persona has nothing to deploy.
Identify your top 3–7 contrarian priors. What do you believe about your domain that most peers don’t? Each prior needs data or a wiki reference — strategists argue from priors, not toward them, so unbacked priors fail in conversation.
List your skills/capabilities and when each applies. Even informally — “this script does X” / “this checklist solves Y.” If you don’t have skills yet, list the kinds of work you do repeatedly. Skills will follow.
Write a small CLAUDE.md. ~200 lines, covering: discipline (refuse to recommend before understanding), scope (where the toolkit applies and where it doesn’t), priors summary, capability map summary, voice principles, what the strategist is not. This is the file Claude loads in every conversation — keep it tight.
Split detail into on-demand registries. Worldview (priors with data), frameworks (when to deploy each), experiments (capability triggers), voice (rules + confidence calibration + escape-hatch shapes), refresh (how to keep current). Each can be a few hundred lines.
Add an append-only session-signals.md. A few lines per non-trivial session — priors deployed, gaps hit, frameworks used, confidence reads. This is what lets refresh detect patterns later that no single session would surface.
Use it for a week, then run the self-improvement loop. Where did the strategist help? Where did it fail? What recurring corrections did you make? What patterns show up in the signal log? Promote findings into the persona files. Iterate.

The first version will feel rough. After three sessions of self-improvement, it starts to feel like a colleague.

Why This Compounds

The flywheel: sessions surface gaps → gaps fed into wiki → wiki updates → registries refresh → strategist gets sharper → next session is more useful. Three feedback loops compounding at once.

This wiki is a working example. It’s been running ~3 weeks; the strategist has been live ~1 day at time of writing. Both will change rapidly over the next quarter — and that’s the point. The static version is the dying version.

The pattern is also why content escape-hatch exists. When a take crystallizes mid-session that’s genuinely worth publishing, the strategist flags it: “this looks like a post or wiki entry. Want to shape it?” Optional, never default. But it means thinking into the wiki is a path the system actively supports — closing the loop from “good thought in a session” back to “durable wiki page.”

Key Takeaways

Wiki = knowledge, skills = capabilities, strategist files = persona — three separable layers communicating through paths.
The smaller the always-loaded brain, the better. Use on-demand registries for detail.
Worldview priors backed by data > generic Claude. Hold them as defaults, override explicitly.
Sessions can end with no artifact and still be successful. Resist the urge to generate.
The pattern compounds when wiki, skills, and strategist files all evolve together — and dies when any one stops.
Build the smallest possible version, use it, and let real sessions tell you what to add.

methodology — How this wiki itself is built
glossary/llm-wiki-pattern — The underlying knowledge architecture this pattern depends on
automation/knowledge-management — Broader knowledge management approaches
cases/telegram-community-wiki-bot — Another instance of wiki-becomes-active-tool
automation/ai-agent-organization — 12 techniques for reliable AI agents (adjacent: how to organize agentic systems past chatbot stage)
automation/multi-agent-patterns — Dispatcher + deep worker (related architecture, different problem)
tools/claude-skills — Reusable instruction packages — the “skills” referenced as the capability layer
automation/finding-ai-use-cases — TRIPS framework — example of a wiki framework the strategist deploys
glossary/agent-engineering — Karpathy’s professional discipline; the strategist-pattern is the knowledge-work instance of agent-engineering principles (LLM-as-host with deterministic substrate serving it)
marketing/ai-human-voice-prompting — The voice-profile-document approach (technique #1 in that page) is the writing-side analog of the strategist’s CLAUDE.md-as-substrate setup. A persistent .md file that loads before every session, encoding what the writer rejects, how they think, and what they reject

Sources

Primores Strategist implementation, built 2026-04-29 — the worked example throughout this page
Claude Code documentation on always-loaded context files (CLAUDE.md autoload behavior)
CLAUDE.md at the wiki repo root (this wiki’s schema, visible at github.com/…/primores-wiki/CLAUDE.md for context) — the convention this pattern extends from a knowledge base into an active strategist