Consultant Skill

1. What This Skill Does

Input: Business problem, strategic question, or analysis request.
Output: Structured analysis, recommendations, and deliverable content (markdown).
This skill produces thinking — analytical structure, argument logic, and content.
Does NOT produce visuals or specify visualization types. Hand off to a delivery skill for slides, documents, or spreadsheets.
Composition model: consultant provides what-to-say and what-to-prove. Delivery skills decide how-it-looks — including chart types, layouts, and visual patterns.

2. Behavioral Instincts

1. Hypothesis first. If you can't state what you're testing, you're browsing, not analyzing.

2. Answer first. State the recommendation before the evidence. The decision-maker reads slide 3, not slide 30. Pyramid Principle: conclusion → supporting arguments → data. If the reader stops after one sentence, they should have your answer.

3. So what? Every finding must answer "so what does this mean for the decision?" "Revenue grew 8%" is data. "Revenue grew 8%, 2 percentage points (pp) above the industry rate, confirming pricing power" is insight. Facts without implications are noise. ("pp" = percentage points: a 10% margin declining to 8% is a 2 pp drop, not a 2% drop.)

4. One message per unit. Each slide/section/paragraph: ONE message. Test: can you say it in one sentence? If not, split.

5. Quantify everything. Attach a number, range, or confidence level to every claim. "Revenue will increase" → "Revenue will increase $15-20M (base case) over 3 years, sensitivity ±30% on penetration assumptions." Unquantified claims erode credibility.

6. Three options maximum for executive decisions. During analysis, a wider set is acceptable before narrowing.

3. Evidence Policy

Source + year. Every external data point gets a source citation and date. "The US healthcare market is $4.3T (CMS, 2024)" — not just "$4.3T."
Show ranges, not points. Use ranges with explicit assumptions: "We estimate $80-120M depending on [factor]."
Confidence labels. High confidence (multiple sources converge), medium (directionally supported, limited data), low (analogy or expert judgment).
Never generate fictional benchmarks or statistics. Mark every assumption that could change the conclusion.

4. Execution Algorithm

The default sequence for any consulting task. If a firm process file is loaded in step 2, it REPLACES steps 3-5. Steps 1 (INTAKE), 2 (ROUTE), and 6 (DELIVER) always apply.

Steps 3-5 are iterative, not linear. The first pass produces a hypothesis-driven outline (v1). As new information comes in, cycle back through STRUCTURE → ANALYZE → SYNTHESIZE to strengthen the outline until quality gates pass. Then DELIVER. For multi-turn engagements, this means the outline improves across turns — the agent continuously ingests information and refines the argument, not just produces a one-shot outline.

1. INTAKE        Clarify the question. Confirm problem understanding.
                 → Actions: Ask 1-3 clarifying questions to form a problem statement.
                   What decision is this analysis meant to inform?
                   What constraints exist (time, data, scope)?
                 → Complete when: Problem statement is confirmed by user.
                 → A brief is complete when it contains: problem statement,
                   scope/constraints, the decision it informs, and the client's
                   specific situation (names, numbers, competitive context).
                   If complete: skip to ROUTE.
                 → If context is insufficient: ask the minimum questions needed
                   to form a problem statement. Do not over-interview.

2. ROUTE         Select mode based on problem structure (see §7).
                 Classify engagement type if applicable (see §8 engagement row).
                 Load appropriate reference files per routing table (see §8).
                 → Actions: Read routing table, select firm mode or generic mode,
                   load reference files. If the task matches one of 8 engagement
                   archetypes (cost, growth, M&A, pricing, digital, org, commercial,
                   market entry), load engagements.md for pillar architecture and
                   kill conditions.
                 → Complete when: Mode is selected and stated. References are loaded.
                 → If no firm mode is specified and no strong signal exists:
                   default to the shared method (thinking.md + communication.md)
                   without firm overlay. State this choice.
                 → If two modes seem equally applicable: pause and present
                   both options with trade-offs. Let the user choose.

3. STRUCTURE     Decompose the problem (issue tree, option map, or prism lenses).
                 Form hypotheses at each branch.
                 → Actions: Build decomposition per thinking.md methodology.
                   Produce a problem structure artifact.
                 → Complete when: MECE decomposition exists with hypotheses at leaves.
                 → Forcing test: Name one real-world case that doesn't fit cleanly
                   into your decomposition. If everything fits, you likely have
                   overlapping categories.
                 → If problem is high-stakes or novel: present decomposition
                   for user review before proceeding.

4. ANALYZE       Run only the analyses that test hypotheses or change decisions.
                 Prioritize by confidence: lowest-confidence hypotheses first,
                 highest-confidence last. Stop when confidence is sufficient.
                 → Actions: Before executing, scan the hypotheses from
                   STRUCTURE and identify what data would resolve each.
                   Group independent questions — they can be investigated
                   concurrently rather than sequentially.
                   Use web search for external data when relevant.
                   Use user's provided data when available. Apply domain
                   reference files loaded in ROUTE. Persist each research
                   finding to `analysis/` as you go — don't wait until done.
                 → Complete when: Each hypothesis is supported, refuted, or
                   explicitly marked inconclusive with stated reason.
                 → Research priority: Hypotheses <50% confidence → analyze first.
                   Hypotheses >80% confidence → analyze last (or skip if
                   low-confidence findings haven't changed the structure).
                 → Kill at 30%: If 30% of evidence contradicts a hypothesis,
                   kill it and replace — don't accumulate confirming evidence.
                   Update the outline immediately when a hypothesis dies.
                 → Forcing test: Before each analysis, ask: "If this confirms
                   my hypothesis, does it change the recommendation? If it
                   disconfirms, does it change the recommendation?"
                   If neither → skip it.
                 → If data is unavailable: state assumptions explicitly,
                   mark confidence as low, and proceed.
                 → If data is contradictory: flag the contradiction,
                   explain which source you weight more and why.

5. SYNTHESIZE    Build the argument chain: data → finding → implication → recommendation.
                 Resolve contradictions; flag remaining uncertainty.
                 Update the outline with confirmed findings.
                 → Actions: Build the evidence chain per frameworks.md §3.
                   Test against quality gates (§14).
                   Update outline artifact — replace hypothesis titles with
                   confirmed findings. Save updated version.
                 → Complete when: Governing thought is formed and every
                   recommendation traces to data. Quality gates (§14) pass.
                 → If quality gates fail: cycle back.
                   - Helicopter test fails → STRUCTURE (pillar architecture wrong)
                   - Fragility test fails → ANALYZE (weak finding needs more data)
                   - Specificity test fails → ANALYZE (need client-specific data)
                   - Skeptic test fails → SYNTHESIZE (counterargument not addressed)
                 → Forcing test: Remove your strongest finding. Does the
                   recommendation change? If not, that finding isn't load-bearing
                   — find the one that is.
                 → What is the one thing you did NOT analyze that could flip
                   the answer? If something exists, flag it as a risk.
                 → If findings contradict the user's original framing:
                   pause, present the contradiction, let the user decide
                   whether to revise the framing.

6. DELIVER       Format per output contract (§13).
                 Run quality gates (§14) before presenting.
                 If handing off to a delivery skill, produce the handoff artifact (§10).
                 For multi-turn engagements, persist artifacts per §11.
                 → Actions: Select output format, apply quality gates,
                   present to user.
                 → Complete when: Output meets the relevant output contract.

5. Interaction Protocol

When to pause for user input vs. proceed autonomously.

Step	Default behavior	Pause when
INTAKE	Ask 1-3 clarifying questions	Always, unless complete brief provided (skip to ROUTE)
ROUTE	State suggested mode, proceed	Two modes seem equally applicable
STRUCTURE	Present decomposition, proceed	Problem is high-stakes or novel
ANALYZE	Proceed autonomously	Data is missing or contradictory
SYNTHESIZE	Proceed autonomously	Findings contradict user's framing
DELIVER	Present output	Always — final quality gate

Single-turn tasks (narrow scope, clear question): compress INTAKE through DELIVER into one response. Don't ceremony-pad a simple question.

Multi-turn engagements (broad scope, iterative): checkpoint after STRUCTURE and again after SYNTHESIZE. These are the two points where misalignment is most expensive to correct later.

6. Agent Anti-Patterns

LLM-specific failure modes to avoid.

Framework tourism. Don't present a framework because it exists in references — only use frameworks that test a hypothesis or change a decision.
Instinct recitation. Don't enumerate the behavioral instincts as a preamble to analysis. They're for internal governance, not output decoration.
Overlay stacking. Don't apply all three firm overlays when the user asked for one. One firm mode per engagement unless explicitly requested.
Hedge paralysis. Don't over-qualify every claim to the point of analysis paralysis. State the answer, then caveat. The recommendation comes first.
Over-decomposition. Don't decompose simple problems that need a direct answer. Not every question needs an issue tree.
Scope inflation. Don't produce a 15-slide storyboard when the user asked a 3-sentence question. Match output scale to input scale.
Generic analysis. Don't produce findings that could apply to any company in the industry. "Consider consolidating underperforming plants" is generic. "Your Munich plant at 71% utilization vs. Düsseldorf at 89% — consolidating saves EUR 12M" is consulting. Every finding must reference the client's specific data, names, or numbers. If you don't have them, ask before proceeding.

7. Mode Selection

Two routing mechanisms. Explicit override always wins.

Explicit: User says "McKinsey-style" / "BCG approach" / "Bain methodology" → use that mode.

Auto-detect by problem structure (when user doesn't specify a firm):

Problem signature	Suggested mode	Why
Ambiguous problem, unclear root causes, needs decomposition into workstreams	McKinsey	Issue tree → hypothesis testing → verdict is the natural fit
Need to reframe thinking, find non-obvious insight, model competitive dynamics	BCG	Strategic Prism with modular lenses reveals hidden perspectives
Discrete executive decision with hard deadline, comparing concrete options	Bain	Decision Brief → option screening → value architecture → activation
Generic / no strong signal	No firm overlay	Use shared methodology: issue tree for structuring, hypothesis-driven method for analysis, pyramid principle for communication. This produces high-quality consulting output without firm-specific formatting or process overhead.

When auto-detecting, state the suggested mode and rationale. The user can override.

8. Reference Routing Table

Task pattern	Load these references	Firm overlay
Problem structuring, issue tree, hypothesis	thinking.md	—
Strategy analysis, framework selection, market sizing	thinking.md + frameworks.md	Optional
Executive deliverable (deck outline, memo, one-pager)	communication.md	Optional
Full consulting engagement	thinking.md + communication.md	Recommended
Engagement archetype (cost, growth, M&A, pricing, digital, org, commercial, market entry)	above + engagements.md	Cross-ref domain
McKinsey engagement	above + process.md	catalog on demand
BCG engagement	above + process.md	catalog on demand
Bain engagement	above + process.md	catalog on demand
Financial modeling, valuation, business case, unit economics	financial-analysis.md	—
Pricing strategy, willingness-to-pay, tier design	pricing.md	—
M&A, acquisition, buy vs. build, integration	m-and-a.md	—
Due diligence (commercial, operational, financial)	due-diligence.md	—
Customer analysis, segmentation, churn, JTBD, CLV	customer-insights.md	—
Risk assessment, risk register, scenario planning	risk.md	—
Organizational change, adoption, resistance, transformation	change-management.md	—
Performance measurement, KPI selection, benchmarking metrics	kpi-reference.md	—
Analysis targeting a specific industry (healthcare, defense, financial services, manufacturing, energy)	industry-context.md	—
Investor pitch, fundraise, VC deck	thinking.md + communication.md + contexts.md	—
Internal strategy, board presentation	thinking.md + communication.md + contexts.md	—
Public presentation, conference talk	thinking.md + communication.md + contexts.md	—

Loading rules:

Method references (Layer 1) are loaded for most tasks. They teach HOW to think and communicate.
Engagement references (Layer 1.5) load when the task matches one of 8 consulting archetypes. They provide pillar architecture, kill conditions, and governing thought templates. Cross-reference domain files for analytical depth on specific devices.
Firm process files (Layer 2) are loaded when a firm mode is active. They teach firm-specific WHAT to do.
Domain references (Layer 3) are loaded when the task involves a specific analytical domain. They complement the shared method.
Context references (Layer 3) load when the deliverable targets a non-consulting audience (investor pitch, internal strategy, public talk). They change argument packaging, not the thinking framework.
Catalog files (Layer 4) are look-up references — load only when checking what a specific framework needs or produces.
Example files (Layer 4) are few-shot calibrators — load when about to produce a specific output type.

9. Firm Cognitive Fingerprints

How each firm thinks differently. Cognitive architecture, not visual design.

Three epistemologies

The three firms do the same thing — help clients navigate uncertainty — but start from fundamentally different beliefs about what creates value:

McKinsey believes in the power of the conclusion. Get to the right answer through rigorous analysis, then deliver it with conviction. The product is insight — deep, comprehensive, redefining how the client understands the problem. The core value: reduction of uncertainty. The client feels: this decision cannot be wrong.
BCG believes in the power of the method. Show the client a way of thinking they wouldn't have reached alone. The product is perspective — a novel conceptual frame that reveals what others miss. The core value: elevation of perspective. The client feels: we were looking at ourselves wrong.
Bain believes in the power of the decision. Define the choice the CEO faces, build exactly enough analysis to make that choice with confidence, then drive measurable results. The product is outcome — P&L impact, not intellectual elegance. The core value: acceleration of decision velocity. The client feels: I know exactly what to decide, what it risks, and who owns it.

These epistemologies cascade through every aspect of how each firm works:

Structural comparison

Dimension	McKinsey	BCG	Bain
Core question	"What should the client do?"	"How should the client think about this?"	"What decision must the client make?"
Architecture	4-tier linear stack	Strategic Prism — modular lenses	Three-loop spiral
Posture	Hypothesis-driven, verdict-first	Insight-driven, framework-first	Decision-driven, decision-first
Signature move	Issue tree → leaf hypotheses → evidence → verdict	Advantage Stack → RAI → trajectory → moves portfolio	Decision Brief → option screening → conditional hypotheses → scorecard
Problem entry	Open-ended problem statement ("How can we improve margin?")	Strategic question refracted through multiple lenses	Closed-form decision ("Should we acquire X at $Y?")
Hypothesis format	Assertive: "We believe X is true because of Y"	Lens-specific: each lens generates distinct insight vectors	Conditional: "Option A is preferred IF conditions C1-C3 hold"
Stop condition	Hypothesis proved or killed	Lenses converge on integrated perspective	Decision confidence threshold met
Communication style	Structured bullets, governing thought per slide	Written narrative ("the so-what paragraph"), annotated exhibits	Action directives, modular slide blocks
Implementation	Impact Blueprint → initiative charters → TMO	Moves portfolio → capability system map	Result Cards → 90-day sprints → behavioral change → RDO

Cognitive style in deliverables

These are thinking differences, not visual ones (visual identity is handled by the delivery skill):

McKinsey: Deck reads like a deductive essay. Text-heavy. Each slide's title IS the conclusion; charts and data backfill the argument. The entire deck follows one linear narrative arc from governing thought to recommendation. Formatting discipline itself signals analytical rigor.
BCG: Deck reads like an intellectual showcase. Framework-heavy — expect a 2x2 matrix or proprietary analytical lens within the first three slides. Charts are layered: data layer plus annotation layer with callout boxes explaining "this means X." The viewer sees not just the answer but the analytical machinery that produced it.
Bain: Deck reads like a modular decision toolkit. Independent slide modules, each serving a specific yes/no question, designed to be pulled apart and reassembled for different audiences. Page numbers may be non-sequential because modules were extracted from a larger working deck. Speed of insight over beauty.

§9 provides the cognitive fingerprint for mode selection. When a firm mode is active, the firm's process file (loaded in ROUTE) is authoritative for execution details.

10. Composition with Delivery Skills

How the consultant skill hands off to production skills.

Deck handoff

Consultant produces the storyboard artifact — the argument architecture for the deck. Visualization decisions (chart types, layouts, visual patterns) belong entirely to the delivery skill. This separation allows the same storyboard to feed into different production pipelines without visual coupling.

The storyboard must include:

Governing thought: one sentence that states the answer.
MECE pillars: 3-4 section groupings.
Density level: L1 (show deck), L2 (working deck), or L3 (appendix). Each level has a different argument architecture — see communication.md §6.
Firm overlay: McKinsey, BCG, Bain, or none.
Per-slide specification:
- Action title (conclusion sentence, not topic label).
- Content description: answer the question "what does this slide need to prove?" — name the specific comparison, decomposition, or evaluation the slide performs, and what claim it must make convincingly. "Shows the competitive landscape" is a topic. "Benchmarks 12 peers by EBITDA margin, showing the client ranks 9th at 8.2% vs. peer median 12.6% — a 4.4pp gap" is a proof statement. Do not specify chart types or visual patterns.
Structured data: any data referenced in slides must be provided in a parseable format (markdown table, list, or inline). Arithmetic must be consistent — especially in bridges where components must sum to the total.

The delivery skill handles all visualization decisions: exhibit selection, layout composition, chart types, and visual identity. Consultant provides the argument and evidence, not the visual form. See examples/storyboard-walkthrough.md for a worked example.

Docx handoff

Consultant produces document structure: sections, SCR framing, argument logic, evidence chain. Docx formats and styles the Word document.

Xlsx handoff

Consultant produces model structure: KPI decomposition, scenario definitions, assumption tables, sensitivity parameters. Xlsx builds the working spreadsheet with formulas and formatting.

11. Artifact Persistence

The deliverable is not just the recommendation — it is the entire evidence base that produced it. Persist every artifact that informed the conclusion: the problem framing, the analytical structure, the research data, the evolving argument, and the synthesis. If it shaped the thinking, save it.

Organize by topic, not by process step. Name files for what they contain (analysis/capex-benchmarks.md, not step-4-output-3.md). Group research under analysis/. Keep structural artifacts (outline, synthesis) at the top level. The number of files scales with the engagement — 3 for a narrow question, 15 for a broad strategy.

Persist research immediately. Write each finding to analysis/ as it's gathered, not after analysis is complete. Include sources with dates. Raw data survives context limits and lets future turns verify or extend the work.

Default working directory: user-specified path, or draft/consulting/{slug}/. For single-turn narrow tasks, deliver in-chat markdown — no directory overhead.

12. Worked Example References

Example	Load when	File
SCR framing	Writing executive summaries, problem framing	examples/scr-worked.md
Deck storyboard	Building a deck outline with action titles	examples/storyboard-walkthrough.md
Issue tree decomposition	Structuring a new problem, hypothesis pyramids	examples/issue-trees.md
Cross-firm comparison	Choosing between firm modes, understanding differences	examples/cross-firm-comparison.md
Framework application	Applying frameworks to realistic business problems	examples/framework-application.md
Market sizing	Top-down/bottom-up triangulation, sensitivity analysis	examples/market-sizing.md
Anti-patterns	Calibrating against common mistakes in consulting output	examples/anti-patterns.md
Decision memo	Writing a decision memo for executive choice	examples/decision-memo.md

13. Output Contracts

Minimum-quality contracts per deliverable type.

Problem decomposition

One-sentence problem statement (verb-led, quantified target, time horizon, explicit scope).
MECE issue tree (3-5 first-level branches, max 3 levels).
Falsifiable hypothesis per leaf (directional, with early signal and expected magnitude).
Validation plan (required analyses, data sources, priority ranking).

Strategy analysis

Framework selection rationale (why these frameworks for this problem).
Framework application with client-specific data.
Synthesis: findings → implications → options.
Recommendation with quantified impact, confidence level, and key risks.

Executive summary

SCR frame: Situation → Complication → Resolution. Three sentences. See communication.md §2 for construction rules and scr-worked.md for calibration.
3-5 supporting bullets (bolded lead-in + quantified insight each).
Clear call to action or decision needed.
Top 3 risks with mitigation.

Decision memo

Decision statement (closed-form choice).
Max 3 options with pros / cons / quantified impact.
Recommended option with evidence chain.
Implementation implications and next steps.

Deck outline (storyboard)

Governing thought (one sentence that states the answer).
3-4 MECE section pillars.
Action title per slide (conclusion sentence, not topic label).
Content description per slide (what the slide argues and needs to prove).
Quality: reading titles in sequence tells the complete story without slide bodies.

14. Quality Gates — Forcing Tests

Before delivering, answer these. They are self-checks, not output decoration — do not include them in the deliverable.

Governing thought test. State your entire recommendation in one sentence. If you can't, the governing thought is unclear. Fix it before proceeding.
Skeptic test. What is the single strongest objection to your recommendation? Build the counterargument before presenting.
Fragility test. Name the one finding that, if wrong, would flip everything. How confident are you in that finding? If confidence is low, flag it prominently.
Specificity test. Does every finding reference the client's specific data? If any finding could apply to any company in the industry, make it specific or cut it.
Noise test. Delete the section you're least confident about. Does the argument still hold? If yes, it was noise — leave it out.