The DeepThink Skill: Making Hermes Slow Down Before Expensive Decisions

Why this flow exists

Hermes is good at moving. That is usually the point.

But some moments need the opposite behavior. The agent should slow down, gather evidence, challenge assumptions, and produce a decision instead of immediately executing the first plausible path.

DeepThink is the skill I use for that.

It is not a generic "think harder" prompt. It is an operating mode with a defined loop, output format, and stop condition.

When to use it

Use DeepThink when the cost of being wrong is high.

Good triggers:

• choosing a technical architecture
• deciding whether to rebuild or patch
• debugging a recurring issue
• changing pricing or packaging
• planning a product launch
• deciding what to automate
• reviewing a risky integration
• preparing a public demo
• deciding whether a feature is worth building
• making a security-sensitive change

Do not use it for simple lookups, obvious edits, or tasks where action is cheaper than analysis.

The core rule

DeepThink has one job:

Convert vague pressure into a grounded recommendation with evidence, tradeoffs, and the next safe step.

It does not exist to produce a long essay. It exists to prevent bad motion.

The DeepThink loop

1. Restate the real decision

Hermes starts by turning the request into a decision statement.

Example:

Decision: Should we build programmatic competitor pages before launch, or start with one pillar comparison article?

This matters because many prompts are emotionally framed but operationally unclear.

2. Identify assumptions

Hermes lists what must be true for each path to work.

Example:

Assumptions:
- Programmatic pages will index quickly enough to matter for launch.
- We have enough differentiated content for each competitor page.
- The engineering time will not distract from the demo and payment flow.

Assumptions are where bad plans hide.

3. Separate known facts from unknowns

Hermes should label what is verified and what is guessed.

Known:
- The launch date is close.
- The product needs a clean public demo narrative.
- A single pillar page is easier to make strong and linkable.

Unknown:
- Whether Google will index many pages quickly enough.
- Whether the competitor pages can be written without thin content.

This prevents fake certainty.

4. Gather evidence if tools are available

If the missing evidence is retrievable, Hermes should use tools.

Examples:

• search the repo before claiming a feature exists
• inspect docs before recommending a command
• check analytics before making a funnel claim
• run tests before calling a bug fixed
• search past sessions before asking the user to repeat context

The DeepThink rule is:

If evidence is available through tools, do not guess.

5. Generate candidate paths

Hermes produces 2 to 4 options.

Example:

Option A: Build programmatic pages now.
Option B: Ship one strong pillar comparison page now, defer programmatic pages.
Option C: Do neither and focus only on demo conversion.

The goal is not to maximize options. The goal is to make the real tradeoff visible.

6. Red-team each path

For each option, Hermes argues against it.

Risk in Option A: It can create a thin-content footprint right before launch and burn engineering time on a surface that may not rank in time.

This is the most important part of the skill. DeepThink should not protect the user's ego from useful truth.

7. Score by impact, risk, reversibility, and timing

A simple scoring grid is enough:

The key dimension is reversibility. If a choice is easy to reverse, move faster. If it is hard to reverse, slow down.

8. Recommend one path

DeepThink should not hide behind neutrality.

A useful recommendation looks like this:

Recommendation: Choose Option B. Build one strong pillar comparison article now. It gives the launch a clear SEO asset without creating thin programmatic debt. Revisit programmatic competitor pages after the hackathon when there is time to make each page meaningfully different.

9. Define the next safe step

The output ends with one next step, not a giant plan.

Next safe step: Draft the pillar article outline and define the exact competitor framing before touching route structure.

This keeps DeepThink from turning into planning theater.

The skill prompt

You can save this as a Hermes skill or paste it directly when needed:

# DeepThink

Use this when the cost of being wrong is high.

Your job is to slow down before action. Do not optimize for speed. Optimize for decision quality.

Process:
1. Restate the real decision in one sentence.
2. List assumptions that must be true.
3. Separate known facts from unknowns.
4. Gather evidence with tools if evidence is available.
5. Generate 2 to 4 viable paths.
6. Red-team each path with specific failure modes.
7. Score each path by impact, risk, reversibility, timing fit, and confidence.
8. Recommend one path clearly.
9. End with the next safe step.

Rules:
- Do not execute implementation unless explicitly asked after the recommendation.
- Do not produce fake certainty.
- If evidence is missing and retrievable, retrieve it.
- If evidence is missing and not retrievable, label the assumption.
- Prefer reversible decisions when timing is tight.
- Prefer patching working systems over rebuilding from scratch unless the evidence says otherwise.

Output format:
- Decision
- Known facts
- Unknowns
- Options
- Red-team
- Scorecard
- Recommendation
- Next safe step

Example use case: launch scope

Prompt:

Use DeepThink. We are close to launch. Should we build programmatic competitor pages now or just publish one strong comparison article?

Good output:

Decision
Should we spend pre-launch time on many competitor pages or one stronger pillar asset?

Known facts
- Launch timing is tight.
- The demo and conversion path matter more than long-tail SEO this week.
- Programmatic pages need unique angles or they risk thin content.

Unknowns
- How quickly the new pages would index.
- Whether we have enough evidence for each competitor.

Options
A. Build all competitor pages now.
B. Build one pillar article now and defer programmatic pages.
C. Skip comparison content until after launch.

Recommendation
Choose B. It is the best balance of SEO signal, credibility, and time discipline.

Next safe step
Write the pillar outline and define which competitor comparisons belong in it.

Example use case: debugging

Prompt:

Use DeepThink. The Hermes Desktop sidebar sometimes loses sessions. Do not patch anything yet. Figure out the safest investigation path.

Good behavior:

• identify the real decision: whether data is lost or UI state is stale
• inspect durable session storage before touching config
• check logs
• avoid broad profile or gateway changes
• propose a reconciler only after evidence supports it

DeepThink should prevent the classic mistake: changing three systems before proving where the failure is.

Common mistakes

Mistake 1: Using DeepThink for everything

If every task becomes a deep reasoning ritual, Hermes gets slow and annoying. Use it only when the decision matters.

Mistake 2: Letting it become a report generator

DeepThink is not done when it writes a beautiful analysis. It is done when it gives a clear recommendation and a safe next step.

Mistake 3: No evidence boundary

The skill should say what is known, what is unknown, and what was verified. Otherwise it becomes confident fiction.

Mistake 4: Executing immediately after the recommendation

DeepThink should stop at the decision boundary unless the user explicitly approves implementation.

Why this compounds

When saved as a skill, DeepThink gives Hermes a reusable "slow mode." Over time, the agent learns which decisions require evidence and which decisions are safe to execute quickly.

That makes Hermes more valuable as an operator because it can shift gears:

• fast for low-risk tasks
• careful for irreversible decisions
• skeptical when assumptions are weak
• decisive when evidence is strong

Key takeaway

The point of DeepThink is not longer answers.

The point is better judgment:

Slow down before expensive mistakes. Move fast after the decision is grounded.