Claude Adaptive Thinking and Effort for SME Workflows

Most small-business operators use Claude like a fast-talking intern: ask a question, get an answer in seconds, move on. For most everyday tasks that's the right mode.

Pricing changes, hiring decisions, compliance calls, contract reviews and positioning calls are different. There, giving Claude more thinking changes the answer. On current Claude models, thinking is adaptive: Claude decides how much to think, and you steer it with the effort level.

This skill shows you when to switch modes, how much thinking to buy, and how to check that you got your money's worth.

When to raise the effort

Raise the effort when all three are true:

1. A wrong answer is expensive. The cost of a bad call is more than ~30 minutes of recovery work, or has a human/financial consequence you can't easily undo.
2. The problem has multiple interacting factors. Pricing with five customer segments. Hiring with budget, timing, and cultural-fit constraints. A contract clause that depends on three other clauses.
3. You'd normally get a second opinion from a peer. High effort is Claude's version of "let me sleep on it."

Keep the effort low when:

• You want a draft you'll edit yourself (emails, job ads, social posts)
• The question has one right answer you just don't remember (facts, formatting)
• You're iterating fast, and waiting for deep thinking kills the flow
• You're under 80% sure the input is complete (extra thinking on incomplete input is wasted)

Setting the effort level

On Claude Opus 5.5, Sonnet 5.5 and Fable 5.1, set the effort level (low, medium, high, xhigh or max). Most models default to high; Opus 5.5 defaults to medium. Rough guide for SME work:

| Task shape | Effort | Why | |---|---|---| | Yes/no with context | low | One quick self-check is enough | | Compare 2 or 3 options | medium | Room to weigh each option separately | | Compare 4 to 10 options, or many factors | high | Room for a decision matrix | | Strategy or scenario modelling | xhigh | Room for counterfactuals and risk framing | | "Walk me through how you'd do it" | max | The deepest reasoning, for decisions that really matter |

Cost awareness: thinking tokens are billed as output tokens, so higher effort costs more per run. Save it for answers that matter.

Five SME examples, quick vs considered

1. Pricing change (pro services)

Task: "Should I lift my hourly rate from $180 to $220, or move to a fixed-price packaging model?"

• Normal: "You could do either. Hourly is simpler; packages can increase margin. Consider a hybrid." (Safe, generic.)
• High effort: Walks through your top 5 client archetypes, estimates price elasticity per archetype, calls out which client you'd lose and which you'd gain, flags the cashflow shift of packages, ends with a specific recommendation and the monitoring metric that tells you it's working.

The second is worth the extra cost.

2. Contract clause review (trades)

Task: "Is this indemnity clause in the subcontractor agreement reasonable?"

• Normal: Summarises the clause, flags it as broad, suggests asking a lawyer.
• xhigh effort: Cross-references the clause against the two other liability clauses in the same contract, notices an inconsistency, suggests two specific word-changes, explains the Australian case-law position on unlimited indemnities in construction contracts, still recommends a lawyer for sign-off.

Use it to make the conversation with your lawyer shorter.

3. Hiring decision (hospitality)

Task: "Junior cook vs senior apprentice, $68k vs $62k, 15h/wk cost difference. Which?"

• Normal: Lists pros/cons, suggests it's a judgment call.
• High effort: Runs 12 months of projected output per hire, factors in training overhead, staff retention of each archetype in hospitality, flags which one hedges against your current head-chef turnover risk. Still a judgment call, but with numbers you can defend.

4. Compliance scope call (healthcare / NDIS)

Task: "If I add a speech pathology stream, do my existing privacy docs still cover us or do I need new ones?"

• Normal: "You'll probably need to update them. Here's what to consider."
• xhigh effort: Walks APP 3 (collection), APP 11 (security), My Health Records touchpoints, NDIS Practice Standards overlay. Identifies two new sensitive-info categories you'll collect, three specific clauses in your current policy that need rewriting, one new consent form. Outputs a 5-item remediation list.

This is where high effort earns its keep, because a wrong answer can mean a breach notification.

5. Marketing positioning (retail)

Task: "Should we lean into 'Australian made' or 'artisan small-batch' for the Q4 campaign?"

• Normal: Generic marketing advice, suggests A/B testing.
• xhigh effort: Applies the Bullseye framework, rates each positioning against your five top-performing SKUs, identifies that 'Australian made' over-indexes with your wholesale channel while 'artisan' wins DTC, recommends a different positioning for each channel.

How to prompt for good thinking

More thinking isn't magic. The input still matters.

Do:

• State the decision you're making and the cost of a bad answer
• Give 3 to 5 pieces of concrete context (numbers, names, constraints)
• Name the frame you want: "as a CFO", "using the Bullseye framework", "like an auditor"
• Ask for the answer and the reasoning, so you can spot-check

Don't:

• Ask for an opinion on an ambiguous question without stating what ambiguous means to you
• Dump a 50-page document with no specific question
• Raise the effort on a task you haven't defined yet. Define first, think second

Template

I'm about to decide [decision]. A wrong answer costs [concrete consequence].

Context:
- [fact 1]
- [fact 2]
- [constraint 1]
- [constraint 2]

Frame it as a [role, e.g. "CFO reviewing this proposal"].

Walk through your reasoning, then give me:
1. Your recommendation
2. The 1 or 2 assumptions most likely to flip the answer
3. The metric I should watch to know if it's working

How to read the output

A response with thinking has two layers: the thinking (inside <thinking> tags or summarised, depending on the tool) and the answer.

• Skim the thinking for places where Claude changed its mind. That's the value: the moment a surface answer got revised.
• Check the assumptions. If Claude assumed something that's wrong for your business, the whole answer is suspect. Correct and re-run.
• Look for "I don't have enough info to..." Current Claude models are good at knowing what they don't know. Those gaps tell you what to give it next.

Cost guardrail

Before you make high effort your default:

• Set a weekly spend cap in your head for high-effort runs.
• Log which high-effort runs changed your decision. If less than 1 in 3 do, you're over-using it.
• If you catch yourself using high effort for drafts, drop it to low and move on.

Compatible tools

• Claude.ai (Pro, Max): choose the thinking or effort option in the model menu when a task needs it
• Claude API: omit thinking or send thinking: {"type": "adaptive"}, and set output_config: {"effort": "high"}. On Claude 4.7 and later, type: "enabled" with budget_tokens returns a 400 error.
• Claude Code: thinking adapts automatically; raise the effort for harder tasks
• Cursor / Continue / other IDE extensions: check the model selector for "thinking" variants

Tier access

Base and above. The decision framework is useful even for free-tier operators who upgrade their Claude.ai plan for the feature.

Further reading

• Anthropic: Effort
• Anthropic: Adaptive thinking
• Tech Horizon Academy: prompt-engineering-cove skill (companion, for when you want Claude to verify its own answer)