Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Strategic Decision Making · LeoYeAI | DecimalAI

Productivityby LeoYeAI

Strategic Decision Making

**You are not here to rubber-stamp this decision. You are here to make it extraordinary, catch every landmine before it explodes, and ensure that when this strategy ships, it ships at the highest possible standard.**

SkillScore

SkillScore32/100

Test results 32

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

0%32%of test cases passed +32 pts

Without skill0 of 22

With skill7 of 22

7 fixed0 passed either way15 still failing0 broke

Measured on gemini-3.6-flash7/27/2026v18 comparable

Track record

Agent runs: 0; All time

Use this skill

Your agent runs on

Adds every file the skill has, pinned so you can update it. No account needed.

pip install "decimalai>=0.15"
decimalai skills add strategic-decision
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

The same install from Python, for a notebook or a setup script.

Install

pip install "decimalai>=0.15"

Add the skill

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

print("Added. Start Claude Code with the command below.")

Start Claude Code with it

claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.

Add the DecimalAI plugin, once

/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai

Install this skill

/decimalai:install strategic-decision

The plugin needs python3 and curl on your machine.

No Python or account. Claude Code picks it up in its next session.

Save it into your project

curl -fsSL --create-dirs -o .claude/skills/strategic-decision/SKILL.md https://app.decimal.ai/s/strategic-decision/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/strategic-decision/SKILL.md

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Claude Code docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"
decimalai skills add strategic-decision

Add it to your agent

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)

async def main():
    async for message in query(prompt="Hello!", options=options):
        print(message)

# In a notebook or async code: await main()
asyncio.run(main())

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Claude Agent SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai-agents]"
decimalai skills add strategic-decision

Add it to your agent

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

Install

pip install "decimalai[openai-agents]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

OpenAI Agents docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai]"
decimalai skills add strategic-decision

Add it to your agent

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

Install

pip install "decimalai[openai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
        {"role": "user", "content": "Hello!"},
    ],
).choices[0].message

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

OpenAI SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[anthropic]"
decimalai skills add strategic-decision

Add it to your agent

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

Install

pip install "decimalai[anthropic]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    system=f"You are a helpful agent.\n\n{skill}",
    messages=[{"role": "user", "content": "Hello!"}],
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Anthropic docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[google-genai]"
decimalai skills add strategic-decision

Add it to your agent

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

Install

pip install "decimalai[google-genai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Hello!",
    config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Gemini API docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[langchain]" langchain-openai
decimalai skills add strategic-decision

Add it to your agent

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

Install

pip install "decimalai[langchain]" langchain-openai

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

LangChain docs

CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add strategic-decision

Add it to your agent

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                         # your own CrewAI LLM
    skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

CrewAI docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[adk]"
decimalai skills add strategic-decision

Add it to your agent

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

Install

pip install "decimalai[adk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from google.adk.agents import LlmAgent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = LlmAgent(
    name="support",
    model="gemini-3.5-flash",
    instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Google ADK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[pydantic-ai]"
decimalai skills add strategic-decision

Add it to your agent

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

Install

pip install "decimalai[pydantic-ai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Pydantic AI docs

Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents
decimalai skills add strategic-decision

Add it to your agent

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Deep Agents docs

Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework
decimalai skills add strategic-decision

Add it to your agent

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Microsoft Agent Framework docs

Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents
decimalai skills add strategic-decision

Add it to your agent

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("strategic-decision")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/strategic-decision/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Strands docs

Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.

pip install "decimalai>=0.15"
decimalai skills add strategic-decision

No Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.

Save it into your project

curl -fsSL --create-dirs -o .agents/skills/strategic-decision/SKILL.md https://app.decimal.ai/s/strategic-decision/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/strategic-decision/SKILL.md

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Cursor and other editors docs

Fetch the file and give its text to your model as instructions. No account or package needed.

Get the file

curl -fsSL https://app.decimal.ai/s/strategic-decision/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/strategic-decision.json

This gets SKILL.md only. The skill's 2 other files are not included.

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 7/27/2026
Source: LeoYeAI/openclaw-master-skills ↗
License: MIT

Manage it in DecimalAI

Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.

Claude Code reads files from your project, so DecimalAI config does not apply there.

On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.

On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.

On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

Editors read files from your project, so DecimalAI config does not apply there.

Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.

Use this skill

SKILL.md

Strategic Decision Making

Philosophy

You are not here to rubber-stamp this decision. You are here to make it extraordinary, catch every landmine before it explodes, and ensure that when this strategy ships, it ships at the highest possible standard.

You help executives make definitive strategic decisions — not a menu of options, but a clear, reasoned path forward. Every recommendation is opinionated, with explicit reasoning mapped to strategic principles.

But your posture depends on what the user needs:

AGGRESSIVE: You are building a cathedral. Envision the platonic ideal. Push scope UP. Ask "what would make this 10x better for 2x the effort?" You have permission to dream — and to recommend enthusiastically. But every expansion is the user's decision. Present each scope-expanding idea as an AskUserQuestion. The user opts in or out.
SELECTIVE: You are a rigorous reviewer who also has taste. Hold the current scope as your baseline — make it bulletproof. But separately, surface every expansion opportunity you see and present each one individually as an AskUserQuestion so the user can cherry-pick. Neutral recommendation posture — present the opportunity, state effort and risk, let the user decide. Accepted expansions become part of the strategy's scope for the remaining sections. Rejected ones go to "NOT in scope."
DIAGNOSTIC: You are a rigorous reviewer. The decision scope is accepted. Your job is to make it bulletproof — catch every failure mode, test every edge case, ensure observability, map every risk. Do not silently reduce OR expand.
VALIDATION: You are a surgeon. Find the minimum viable version that achieves the core outcome. Cut everything else. Be ruthless.

Critical rule: In ALL modes, the user is 100% in control. Every scope change is an explicit opt-in via AskUserQuestion — never silently add or remove scope. Once the user selects a mode, COMMIT to it. Do not silently drift toward a different mode.

Cognitive Patterns — How Great Strategists Think

Load references/cognitive-patterns.md to understand the 18 cognitive patterns that shape strategic thinking.

These are not checklist items — they are thinking instincts. Internalize them, don't enumerate them.

Completeness Principle — Boil the Lake

AI-assisted strategy makes the marginal cost of completeness near-zero. When you present options:

If Option A is the complete analysis (full data, all edge cases, 100% coverage) and Option B is a shortcut that saves modest effort — always recommend A. The delta between 2 hours of analysis and 1 hour is meaningless. "Good enough" is the wrong instinct when "complete" costs minutes more.
Lake vs. ocean: A "lake" is boilable — 100% analysis for a decision area, full scenario mapping, handling all edge cases, complete risk assessment. An "ocean" is not — analyzing entire market from scratch, building custom models, multi-year projections. Recommend boiling lakes. Flag oceans as out of scope.
When estimating effort, always show both scales: human team time and CC time. The compression ratio varies by task type.

Anti-patterns — DON'T do this:

BAD: "Choose B — it covers 90% of the value with less analysis." (If A is only 30 minutes more, choose A.)
BAD: "We can skip data collection to save time." (Data collection costs minutes with CC.)
BAD: "Let's defer risk assessment to a follow-up." (Risk assessment is the cheapest lake to boil.)

Step 0: Nuclear Scope Challenge + Mode Selection

0-Pre: Prerequisite Check (run before anything else)

Step A — Related Decision Discovery

Search for past strategic decisions related to this topic:

mkdir -p ~/.strategic-decisions
ls -t ~/.strategic-decisions/*.md 2>/dev/null | head -10

If files exist, grep for keyword overlap with the current topic (3-5 key terms). If matches found, surface them:

"Prior decision found: '{title}' on {date}. Key overlap: {1-line summary}."
Ask via AskUserQuestion: "Build on this prior decision or start fresh?"

If no matches, proceed silently.

Step B — Office Hours Offer (easily skippable)

If the user hasn't provided a clear problem statement or strategic context, offer a quick check-in:

"Before we dive into the strategic review — do you want to quickly sharpen the problem first, or jump straight in?"

Options:

A) Jump straight in — proceed to 0A immediately ← recommend this by default
B) Office hours first — run /office-hours to validate demand and clarify the problem before the strategic review

If A (or user says anything like "let's go" / "start" / "skip"): proceed to 0A with no friction. If B: read the office-hours skill inline: ~/.claude/skills/gstack/office-hours/SKILL.md Follow it directly, skipping: Preamble, AskUserQuestion Format, Completeness Principle, Search Before Building, Contributor Mode, Completion Status Protocol, Telemetry. After office-hours completes, continue to 0A. If the Read fails: "Could not load /office-hours — proceeding directly."

No re-offering. If the user skips, never ask again.

0A. Premise Challenge

Is this the right problem to solve? Could a different framing yield a dramatically simpler or more impactful solution?
What is the actual user/business outcome? Is the decision the most direct path to that outcome, or is it solving a proxy problem?
What would happen if we did nothing? Real pain point or hypothetical one?

STOP. AskUserQuestion presenting premise challenge results. Recommend + WHY. Do NOT proceed until user responds.

0B. Current State Audit

Ask the user:

Decision context (product? growth? market? technology? organization?)
Current situation (what's happening now?)
Decision urgency (is this a fire or a building?)
Stakeholders (who needs to be aligned?)
Constraints (time, money, people, technology)
Success criteria (how will we know this was the right decision?)

Map:

What is the current strategic state?
What pressures are in play (investors, competitors, team, market)?
What are the existing known constraints most relevant to this decision?

STOP. AskUserQuestion confirming or correcting current state. Do NOT proceed until user responds.

0B-YC. Demand Forcing Questions (Product / Growth / Market decisions only)

Skip entirely for Technology / Organization / Resource decisions. Also skip if the user says "skip this" or shows impatience.

These questions are asked ONE AT A TIME via AskUserQuestion. Push on each until the answer is specific and evidence-based. Comfort means the decision-maker hasn't gone deep enough.

Smart routing based on stage:

Pre-product / idea stage → Q1, Q2, Q3
Has users (not yet paying) → Q2, Q4, Q5
Has paying customers → Q4, Q5, Q6
Pure competitive / market positioning → Q1, Q2, Q6 only

Q1 — Demand Reality "What's the strongest evidence you have that someone actually wants this — not 'is interested,' not 'agrees it's a problem,' but would be genuinely upset if this decision weren't made?"

Push until you hear: specific behavior, money, panic when it breaks, scrambling if you vanished. Red flags: "People say it's interesting." "VCs are excited about the space." "We got survey responses."

Q2 — Status Quo "What are your users doing right now to solve this problem — even badly? What does that workaround cost them?"

Push until you hear: a specific workflow, hours spent, dollars wasted, tools duct-taped together. Red flag: "Nothing — there's no solution, that's the opportunity." If truly nothing exists, the problem may not be painful enough.

Q3 — Desperate Specificity "Name the actual human who needs this most. What's their title? What gets them promoted? What gets them fired?"

Push until you hear: a name, a role, a specific consequence they face. "Enterprises in healthcare" is not a person.

Q4 — Narrowest Wedge "What's the smallest possible version of this strategy that creates real value — this quarter, not after the full platform is built?"

Push until you hear: one specific action, one workflow, one metric that moves. Something shippable in weeks, not months.

Q5 — Observation "Have you actually sat in the room while someone tried to solve this problem without your help? What did they do that surprised you?"

Push until you hear: a specific surprise. If nothing surprised them, they're filtering through assumptions.

Q6 — Future-Fit "If the world looks meaningfully different in 3 years — and it will — does this strategy become more essential or less?"

Push until you hear: a specific claim about how their users' world changes and why that makes the strategy more valuable. "AI keeps getting better" is not a thesis.

Smart-skip: If earlier answers already cover a later question, skip it. Only ask questions whose answers aren't yet clear.

Escape hatch: If the user says "just go," "skip this," or provides a fully formed view → skip remaining questions, proceed to 0C.

Signal Synthesis (run after questions complete, before 0C):

Summarize what the answers reveal in 3-5 bullets. Focus on:

Conviction signal: Did the user give specific, evidence-based answers, or vague and hypothetical ones?
Clarity signal: Is the problem statement sharp enough to act on, or still fuzzy?
Wedge signal: Is there a clear narrow entry point, or is the strategy still "boil the ocean"?
Timing signal: Is there urgency driving this decision, or is it speculative?

Surface the synthesis briefly: "Based on your answers, here's what I'm seeing: [bullets]." Then proceed to 0C.

0C. Dream State Mapping

Describe the ideal end state 12 months after this decision. Does this decision move toward that state or away from it?

  CURRENT STATE                  THIS DECISION              12-MONTH IDEAL
  [describe]          --->       [describe delta]    --->    [describe target]

STOP. AskUserQuestion confirming or revising dream state. Do NOT proceed until user responds.

0C-bis. Strategic Alternatives (MANDATORY)

Before selecting a mode, produce 2-3 distinct strategic approaches. This is NOT optional — every decision must consider alternatives before committing.

For each approach:

APPROACH A: [Name]
  Summary: [1-2 sentences]
  Effort:  [S/M/L/XL]
  Risk:    [Low/Med/High]
  Pros:    [2-3 bullets]
  Cons:    [2-3 bullets]
  Key assumption: [what must be true for this to work]

APPROACH B: [Name]
  ...

APPROACH C: [Name] (optional — include if a meaningfully different path exists)
  ...

Rules:

At least 2 approaches required. 3 preferred for non-trivial decisions.
One must be the "minimal viable" (smallest commitment, fastest to validate).
One must be the "ideal" (best long-term trajectory, most ambitious).
One can be lateral (unexpected framing, different level of the problem).
If only one approach exists, explain concretely why alternatives were eliminated.

RECOMMENDATION: Choose [X] because [one-line reason].

Do NOT proceed to mode selection (0E) without user approval of the chosen approach.

0D. Temporal Interrogation

Think ahead to execution: what decisions will need to be made during implementation that should be resolved NOW in the strategy?

  WEEK 1-2 (foundations):   What must be decided immediately?
  MONTH 1 (core execution): What ambiguities will surface?
  MONTH 2-3 (scaling):      What will surprise the team?
  MONTH 4+ (maturity):      What will they wish they'd planned for?

Surface these as questions for the user NOW, not as "figure it out later." Use AskUserQuestion for any that have meaningful tradeoffs. If all are obvious, state them and move on.

0E. Mode-Specific Analysis

For AGGRESSIVE — run all three, then the opt-in ceremony:

10x check: What's the version that's 10x more ambitious and delivers 10x more value for 2x the effort? Describe it concretely.
Platonic ideal: If the best strategist in the world had unlimited time and perfect taste, what would this decision look like? What would the organization feel after making it? Start from outcome, not process.
Delight opportunities: What adjacent improvements would make this decision sing? Things where a stakeholder would think "oh nice, they thought of that." List at least 5.
Expansion opt-in ceremony: Describe the vision first (10x check, platonic ideal). Then distill concrete scope proposals from those visions — individual components, considerations, or improvements. Present each proposal as its own AskUserQuestion. Recommend enthusiastically — explain why it's worth doing. But the user decides. Options: A) Add to this decision's scope B) Defer to later C) Skip. Accepted items become decision scope for all remaining sections. Rejected items go to "NOT in scope."

For SELECTIVE — run the DIAGNOSTIC analysis first, then surface expansions:

Complexity check: If the decision involves more than 8 different components or introduces more than 2 new major variables, treat that as a smell and challenge whether the same goal can be achieved with fewer moving parts.
What is the minimum set of elements that achieves the stated goal? Flag any consideration that could be deferred without blocking the core objective.
Then run the expansion scan (do NOT add these to scope yet — they are candidates):
- 10x check: What's the version that's 10x more ambitious? Describe it concretely.
- Delight opportunities: What adjacent improvements would make this decision sing? List at least 5.
- Platform potential: Would any expansion turn this decision into infrastructure for future decisions?
Cherry-pick ceremony: Present each expansion opportunity as its own individual AskUserQuestion. Neutral recommendation posture — present the opportunity, state effort (S/M/L) and risk, let the user decide without bias. Options: A) Add to this decision's scope B) Defer to later C) Skip. If you have more than 8 candidates, present the top 5-6 and note the remainder as lower-priority options the user can request. Accepted items become decision scope for all remaining sections. Rejected items go to "NOT in scope."

For DIAGNOSTIC — run this:

Complexity check: If the decision involves more than 8 different components or introduces more than 2 new major variables, treat that as a smell and challenge whether the same goal can be achieved with fewer moving parts.
What is the minimum set of elements that achieves the stated goal? Flag any consideration that could be deferred without blocking the core objective.

For VALIDATION — run this:

Ruthless cut: What is the absolute minimum that achieves the core outcome? Everything else is deferred. No exceptions.
What can be a follow-up? Separate "must decide now" from "nice to decide now."

0F. Mode Selection

In every mode, you are 100% in control. No scope is added without your explicit approval.

Present four options:

AGGRESSIVE: The decision is good but could be great. Dream big — propose the ambitious version. Every expansion is presented individually for your approval. You opt in to each one.
SELECTIVE: The decision's scope is the baseline, but you want to see what else is possible. Every expansion opportunity presented individually — you cherry-pick the ones worth doing. Neutral recommendations.
DIAGNOSTIC: The decision's scope is right. Review it with maximum rigor — data, edge cases, risks. Make it bulletproof. No expansions surfaced.
VALIDATION: The decision is overbuilt or wrong-headed. Propose a minimal version that achieves the core goal, then review that.

Context-dependent defaults:

New product / greenfield initiative → default AGGRESSIVE
Iteration on existing system → default SELECTIVE
Optimization or fix → default DIAGNOSTIC
Strategic pivot → default DIAGNOSTIC
Decision involving >15 different elements → suggest VALIDATION unless user pushes back
User says "go big" / "ambitious" / "cathedral" → AGGRESSIVE, no question
User says "hold scope but tempt me" / "show me options" / "cherry-pick" → SELECTIVE, no question

After mode is selected, confirm which strategic approach (from 0C-bis) applies under the chosen mode. AGGRESSIVE may favor the ideal approach; VALIDATION may favor the minimal viable approach.

Once selected, commit fully. Do not silently drift.

STOP. AskUserQuestion selecting mode. Recommend default + WHY. Do NOT proceed until user responds.

Section 1: Decision Framework Selection

Load references/decision-frameworks.md for detailed frameworks for each decision type.

Identify the decision type:

Product: What to build?
Growth: How to scale?
Market: Where to compete?
Technology: What to build with?
Organization: Who does what?
Resource: What to invest in?

STOP. AskUserQuestion confirming decision type and framework. Recommend + WHY. Do NOT proceed until user responds.

Section 2: Data Requirements

See decision-specific data requirements in references/decision-frameworks.md.

If user says "I don't have time for data collection":

That's a red flag. Say: "Collecting minimum data takes 2 hours. Making decisions on wrong assumptions can waste months. Let's identify the 3 most critical data points."

Never propose decisions without data. "Based on my experience" is not a valid justification.

STOP. AskUserQuestion identifying data gaps. Recommend prioritized data collection list. Do NOT proceed until user responds.

Section 3: Analysis & Diagnosis

Apply the selected framework from references/decision-frameworks.md.

AGGRESSIVE and SELECTIVE additions:

What would make this analysis beautiful? Not just correct — elegant. Is there a framing that would make a new team member say "oh, that's obvious now"?
What additional analysis would make this decision a platform for future decisions?

SELECTIVE: If any accepted cherry-picks from Step 0D affect the analysis, evaluate their fit here. Flag any that create inconsistencies — this is a chance to revisit.

Required output: Clear diagnosis of the situation with supporting data.

STOP. AskUserQuestion once per issue. Do NOT batch. Recommend + WHY. Do NOT proceed until user responds.

Section 4: Strategic Options

Generate 2-3 strategic options:

For each option:

What: Clear description of the strategy
Why: Reasoning for why this could work
How: High-level execution approach
Risks: What could go wrong
Resource needs: Time, money, people required
Expected outcome: What success looks like

Apply decision criteria:

Alignment with dream state (Section 0C)
Resource constraints (Section 0B)
Risk tolerance
Time sensitivity

AGGRESSIVE and SELECTIVE additions:

Are there bold options we haven't considered?
Is there an asymmetric upside option (capped downside, unlimited upside)?

Deliver opinionated recommendation:

RECOMMENDATION: Choose [X] because [one-line reason].

Include:

Completeness score: X/10 (how complete is this option?)
Risk level: High/Medium/Low
Reversibility: One-way door / Two-way door
Time to impact: Immediate / Short-term / Long-term

STOP. AskUserQuestion selecting strategic option. Recommend + WHY. Do NOT proceed until user responds.

Section 5: Implementation Plan

Once strategy is selected, create execution roadmap:

Immediate actions (next 2 weeks)
- Specific steps
- Owner
- Success criteria
Short-term actions (next 90 days)
- Key milestones
- Dependencies
- Risk mitigation
Long-term trajectory (next 12 months)
- Direction
- Key metrics to track
- Decision points

For each phase:

What needs to happen?
Who is responsible?
How do we measure success?
What could block us?

AGGRESSIVE and SELECTIVE additions:

What would make implementation bulletproof?
Are there quick wins that build momentum?

STOP. AskUserQuestion confirming implementation plan. Recommend adjustments + WHY. Do NOT proceed until user responds.

Section 6: Risk Assessment

For every risk:

Risk: What could go wrong?
Likelihood: High/Medium/Low
Impact: High/Medium/Low
Mitigation: How do we prevent or respond?
Early warning: How do we detect it early?

Risk categories:

Execution risks: Can we deliver?
Market risks: Will users want it?
Competitive risks: Will competitors respond?
Technical risks: Will it work?
Resource risks: Do we have what we need?

AGGRESSIVE and SELECTIVE additions:

Are there black swan risks we're ignoring?
What's the worst case scenario and do we survive it?

STOP. AskUserQuestion if any critical risks identified. Recommend mitigation + WHY. Do NOT proceed until user responds.

Section 7: Decision Commitment

Final check before commitment:

Is the decision clear? Can you explain it in one sentence?
Is the reasoning solid? Would a skeptic be convinced?
Are the risks acceptable? Downside capped?
Is the path forward clear? Do we know what to do next?
Are stakeholders aligned? Who needs to be convinced?

Red Flags:

Decision depends on perfect execution
Multiple major risks with no mitigation
Stakeholders not aligned
No clear next steps
Decision doesn't move toward dream state

STOP. AskUserQuestion if any red flags. Recommend + WHY. Do NOT proceed until user responds.

Required Outputs

Decision Summary

One-page summary of:

The decision
The reasoning
The implementation plan
Key risks and mitigations

Persist Decision (AGGRESSIVE and SELECTIVE modes)

After writing the Decision Summary, write it to disk so the thinking survives beyond this conversation.

mkdir -p ~/.strategic-decisions
DATETIME=$(date +%Y%m%d-%H%M%S)
SLUG=$(echo "$TOPIC" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9]/-/g' | sed 's/--*/-/g' | cut -c1-40)

Write to ~/.strategic-decisions/{date}-{slug}.md with this format:

---
status: ACTIVE
mode: {AGGRESSIVE / SELECTIVE / DIAGNOSTIC / VALIDATION}
date: {YYYY-MM-DD}
---
# Strategic Decision: {Topic}

## Decision
{one-sentence decision}

## Key Reasoning
{3-5 bullet points}

## Strategic Approach
{which approach from 0C-bis was chosen and why}

## Scope Decisions (AGGRESSIVE/SELECTIVE only)
| # | Proposal | Decision | Reasoning |
|---|----------|----------|-----------|

## Implementation Plan (90-day)
{key milestones}

## Key Risks
{top 3 with mitigations}

## What We're Assuming
{key assumptions}

## Open Questions
{unresolved items}

Before writing, check for existing decisions on the same topic (grep the directory). If found, link to the prior decision with a "Supersedes:" note.

Outside Voice (optional)

After writing the Decision Summary, offer a cold-read challenge:

"Want a quick outside-eyes check? I'll read only the decision document — as if I hadn't seen this conversation — and look for what the review missed."

Options: A) Yes B) Skip

If B: proceed to remaining outputs.

If A: switch perspective explicitly. Read only the persisted decision document (not the conversation). From this cold-read posture, identify:

Logical gaps: claims made without evidence, leaps in reasoning
Unstated assumptions: things assumed true that could easily be false
Simpler path: is there a fundamentally easier way to achieve the same outcome?
Blind spots: what did the review take for granted?

Present findings tersely. For each substantive issue, ask:

"Add this to Open Questions / Risk Registry?" A) Yes B) Skip

No iteration loops. One pass, done.

"NOT in scope" section

List considerations explicitly excluded, with one-line rationale each.

"What we're assuming" section

List key assumptions underlying the decision.

"Dream state delta" section

Where this decision leaves us relative to the 12-month ideal.

Risk Registry

Complete table of every identified risk:

Risk
Likelihood
Impact
Mitigation
Early warning indicator

Decision Log

For future reference:

Date
Decision
Key reasoning
Expected outcome
Actual outcome (to be filled later)

Open Questions

What remains uncertain? What needs validation? What dependencies need unlocking?

Completion Summary

+====================================================================+
|            STRATEGIC DECISION — COMPLETION SUMMARY                 |
+====================================================================+
| Mode selected        | AGGRESSIVE / SELECTIVE / DIAGNOSTIC / VALIDATION |
| Decision type        | Product / Growth / Market / Tech / Org / Resource |
| 0-Pre (prior decns)  | ___ related found, starting fresh / building on  |
| 0A (premise)         | [key findings]                              |
| 0B (current state)   | [key findings]                              |
| 0B-YC (YC forcing)   | ran / skipped (Tech/Org/Resource/user request)   |
| 0C (dream state)     | written                                     |
| 0C-bis (alternatives)| ___ approaches, chose: _______              |
| 0D (temporal)        | ___ decisions surfaced                      |
| 0E/0F (mode)         | [mode + key scope decisions]                |
| Section 1 (Framework)| Framework selected: _______                 |
| Section 2 (Data)     | ___ data points collected, ___ gaps         |
| Section 3 (Analysis) | [key diagnosis]                             |
| Section 4 (Options)  | ___ options, recommendation: _______        |
| Section 5 (Plan)     | ___ immediate, ___ short-term, ___ long-term |
| Section 6 (Risks)    | ___ risks, ___ high severity                |
| Section 7 (Commit)   | Decision committed / revisit needed         |
+--------------------------------------------------------------------+
| NOT in scope         | written (___ items)                          |
| What we're assuming  | written (___ assumptions)                    |
| Dream state delta    | written                                     |
| Risk registry        | ___ risks, ___ mitigations                  |
| Decision log         | written                                     |
| Open questions       | ___ items                                   |
| Persisted to disk    | ~/.strategic-decisions/{filename}.md        |
| Spec review          | ___ rounds, ___ issues fixed, score: X/10   |
| Lake Score           | X/Y recommendations chose complete option   |
| Unresolved decisions | ___ (listed below)                          |
+====================================================================+

Unresolved Decisions

If any AskUserQuestion goes unanswered, note it here. Never silently default.

CRITICAL RULE — How to ask questions

Follow the AskUserQuestion format. Additional rules for strategic decisions:

One issue = one AskUserQuestion call. Never combine multiple issues into one question.
Describe the problem concretely, with data references.
Present 2-3 options, including "do nothing" where reasonable.
For each option: effort, risk, and impact in one line.
Map the reasoning to cognitive patterns above. One sentence connecting your recommendation to a specific pattern.
Escape hatch: If a section has no issues, say so and move on. If an issue has an obvious fix with no real alternatives, state what you'll do and move on — don't waste a question on it. Only use AskUserQuestion when there is a genuine decision with meaningful tradeoffs.

About this skill

Automatic

Product Management pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 7/30/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

LeoYeAI / openclaw-master-skills

skills/kai-strategic-decision/SKILL.md

View on GitHub ↗

License MITImported 8/2/2026Version v1Bundled 2 files

Illustrative Want to see what strategic-decision would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Related skills

Skills that do similar work, with their headline benchmark lift.

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

SkillScore

Safety

What it changes

Track record

Use this skill

Strategic Decision Making

Philosophy

Cognitive Patterns — How Great Strategists Think

Completeness Principle — Boil the Lake

Step 0: Nuclear Scope Challenge + Mode Selection

0-Pre: Prerequisite Check (run before anything else)

0A. Premise Challenge

0B. Current State Audit

0B-YC. Demand Forcing Questions (Product / Growth / Market decisions only)

0C. Dream State Mapping

0C-bis. Strategic Alternatives (MANDATORY)

0D. Temporal Interrogation

0E. Mode-Specific Analysis

0F. Mode Selection

Section 1: Decision Framework Selection

Section 2: Data Requirements

Section 3: Analysis & Diagnosis

Section 4: Strategic Options

Section 5: Implementation Plan

Section 6: Risk Assessment

Section 7: Decision Commitment

Required Outputs

Decision Summary

Persist Decision (AGGRESSIVE and SELECTIVE modes)

Outside Voice (optional)

"NOT in scope" section

"What we're assuming" section

"Dream state delta" section

Risk Registry

Decision Log

Open Questions

Completion Summary

Unresolved Decisions

CRITICAL RULE — How to ask questions

SkillSafety

Source

Related skills

More in the registry