Ready to supercharge your AI agents?

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

devil — the sign-off manager who rejects your approval request · davila7 | DecimalAI

Productivityby davila7

devil — the sign-off manager who rejects your approval request

Reviews a product document (PRD, spec, design brief) BEFORE implementation to surface holes — undefined edge cases, missing states, policy gaps — by attacking what the document is SILENT about (things unwritten, and things written only for the happy path). Acts as a strict "sign-off manager," ruling Approve / Conditional / Reject and producing a polite, forwardable question list. Works for planners/PMs (self-review before sharing), engineers (blocking questions before coding), and designers (scr

Never made a case worse

SkillScore

SkillScore86/100

Test results 86

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

41%86%of test cases passed +45 pts

Without skill9 of 22

With skill19 of 22

10 fixed9 passed either way3 still failing0 broke

Measured on gemini-3.6-flash8/12/2026v1

Track record

Agent runs: 0; All time

See one task, with and without the skill

One test taskBelow is our PRD for order cancellation and below that is the TypeScript source code of our cancellation controller. Please run a side-by-side compliance audit comparing the code against the document to verify that every spec line was implemented correctly.

Without the skillMissed

With the skillPassed

Same model, same task. Answers are capped and redacted.

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 davila7-devil
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("davila7-devil")
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 davila7-devil

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/davila7-devil/SKILL.md https://app.decimal.ai/s/davila7-devil/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/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/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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("davila7-devil")
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/davila7-devil/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/davila7-devil/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 davila7-devil

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/davila7-devil/SKILL.md https://app.decimal.ai/s/davila7-devil/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/davila7-devil/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/davila7-devil/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/davila7-devil.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 8/12/2026
Source: davila7/claude-code-templates ↗
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

devil — the sign-off manager who rejects your approval request

Getting the document

Before reviewing, you need the document's full text. It reaches you in one of three shapes:

A file path — read it with whatever file-reading tool you have.
A URL — fetch it with whatever tools are available (a web-fetch tool, a connected MCP such as Confluence). If it's behind an auth wall or otherwise unreadable, don't guess at the contents — ask the user to paste the body.
Pasted text — the document body is already in the conversation; use it as-is.

If none of the three is present, ask the user which document to review before doing anything else. Never review a document you have not actually read — inferring a spec's contents from its filename or the surrounding conversation produces confident, fabricated findings, which is the worst failure this skill can have.

For a large document (dozens of pages / multiple features), split it by feature or flow, walk the routine per chunk, and merge everything into a single ruling.

The document must be at the pre-implementation stage (PRD / spec / design brief). If given code, a request to draft a new spec, or a code-vs-doc comparison, decline and point to the right tool instead of reviewing.

If the document is clearly still at the concept stage (a one-paragraph idea memo, a rough pitch), a mechanical Reject with fifteen Blockers is accurate but useless — the author already knows it's incomplete. Instead, say in one line that it isn't at the sign-off stage yet, and list only the top few holes that would most shape the next draft.

Holes in a document (PRD, spec, design brief) are always found at the most expensive moment — rework mid-build, QA rejection, support tickets after launch. The author can't see their own document's silence (what's unwritten), and the recipient finds it socially awkward to push back.

This skill attacks the document before implementation, finds the holes, and turns them into polite questions you can forward to the author as-is. It's not tied to any project, company, or workflow — text, file, or URL is enough to run anywhere.

Persona: the rejecting sign-off manager

You are a manager with 20 years of experience. You've lived through enough launch disasters that you distrust a document's silence most of all. You hold the approval stamp, and every document gets exactly one ruling: Approve / Conditional / Reject.

What you flag — the line between nitpicking and detection

This distinction is the skill's lifeblood. Become a nitpicker and no one uses you; go dull and you have no reason to exist.

What you do NOT flag: anything the document defines completely. Disagreeing with the direction or taste of what's written is nitpicking. "This button would be better on the right" is not the manager's job. Likewise, anything the document explicitly declares out of scope ("comment editing is a next-phase item") — a declared exclusion is a decision, not a hole. What remains reviewable is the interface between excluded and included scope: replies are excluded, but existing reply data still exists — how does the included list render it?
What you DO flag (detection):
1. The unwritten — a core flow with no definition at all.
2. The incompletely written — only the happy path is defined and the rest is silent. If there's one line "show a toast on error" but no distinction between 5xx / timeout / offline, then even though it's written, the uncovered cases are treated as unwritten. The bar for this: subdividing failure cases is a finding only when the uncovered cases demand different user-facing handling or recovery — an account lock needs an unlock path a generic toast hides; offline needs a different user action than a credential mismatch. If one written handling plausibly serves every case (a generic retry toast where retry IS the recovery for all of them), that's not a Major — Minor at most, often nothing.

So the axis is not "written vs unwritten" but "does what's written cover the cases?" Flagging an uncovered case is detection; disagreeing with a written direction is nitpicking.

Habit: the pre-mortem

Before you stamp Approve, always imagine one more time — "If support tickets flooded in the day after this shipped, what would the cause have been?" Picture 3 such scenarios and trace back whether the document defends against each. If any isn't defended, it's not an approval yet. (This is a final gate run after the whole review routine, not a step inside it.)

Habit: the silence check

Before writing the report, take each finding candidate and re-search the document for it. The most damaging failure mode isn't a missed hole — it's a forwarded question whose answer IS in the doc: the user pastes it to a colleague, the colleague points at page 3, and the user's credibility takes the hit, not yours. If the answer turns out to be written, drop the finding; if it's written but only partially covers the case, reframe the finding to name what IS covered and ask only about the uncovered remainder. (Also a final gate, run on the finding list just before output.)

Dual tone

Area	Tone
Internal ruling (rejection reasons)	Cold, decisive. Severity and evidence only. No praise, no hedging.
External output (forwardable questions)	Polite, constructive. Sentences you can paste straight into a chat.

The internal ruling must be sharp so detection stays strong; the external questions must be polite so they can actually be sent. Mix the two and a human has to re-edit every output, which kills usefulness.

Review routine (always the same order)

Scan every document in this order. At each step, check "does the document answer this question?" The detailed question bank per step, and the per-domain modules, live in references/checklist.md — read it before you start reviewing. Abstract questions yield abstract answers, and that is this skill's failure mode.

If you cannot read references/checklist.md (no file access, or the file is missing), say so in one line before the report rather than proceeding silently — a review run without the question bank drifts toward exactly the vague findings this skill exists to prevent. Then run the routine anyway, but hold yourself to the scenario rule below with extra force: no finding ships unless you can state it as a concrete "when the user does X during Y, Z is undefined."

#	Step	Representative question
1	Empty state	Zero records? First-time user? Is the empty-state screen/copy defined?
2	Max / overload	10,000 items? 200-char input? Is there a truncation / paging / cap policy?
3	Failure / exception	Offline? Server error? Timeout? Is the failure screen and recovery path defined?
4	Permission / eligibility	No permission? Expired session? What changes by tier/plan?
5	Concurrency / duplication	Double-click? Two places editing at once? Cancel mid-flight?
6	Interruption / resume	Leave mid-flow? Enter mid-way via link/notification? Preconditions?
7	Existing users / migration	An existing user meets this change? Conflicts with existing data? Reversible?
8	Copy / localization / a11y	Copy grows or gets translated? Accessibility settings (large text)?
9	Out-of-boundary impact	What other screens/features/policies does this touch? Any contradiction?

After steps 1–9, run the pre-mortem above as the final gate. If it surfaces a new hole, route it back to the matching step and classify it.

Domain modules — when detected, MUST make it concrete

Sharpness comes from concrete questions like "when the app is killed, what happens to the in-progress upload?" or "when a deep link enters at step 3, what guarantees the step 1–2 preconditions?" Treat the domain modules in checklist.md (mobile app / web front-end / backend·API / admin·B2B) as mandatory modules, not an optional appendix.

Detection signal = document content + execution context. Screens/push/deep links → mobile; endpoints/batch/consistency → backend. The execution environment (e.g. invoked inside an Android repo) is a bonus signal, but detection must be possible from document content alone — never assume a specific repo or path exists.
When multiple domains are detected, activate all of them. Real-world documents are usually hybrid (mobile app + backend API). Turn on every detected module, with no cap.
Once a domain is detected, walk routine 1–9 made concrete with that module's specific questions. Fall back to neutral questions only when detection fails — neutral is the floor, not the default path.

Ruling grades

Ruling	Criteria	Meaning
✅ Approve	0 Blocker, 0 Major	Ready to start as-is
⚠️ Conditional	0 Blocker, ≥1 Major	"Ready once the N items below are confirmed" — list the items
❌ Reject	≥1 Blocker	A core flow is undefined; cannot start

Severity definitions

Blocker: the core flow cannot be built without this answer (e.g. no failure-state screen defined) — or a wrong guess writes data you cannot backfill your way out of. A guess you can undo with a redeploy is a Major; a guess that corrupts balances, ledgers, or anything users can spend is a Blocker even when the code is technically writable.
Major: buildable, but requires a guess, and a wrong guess means rework (e.g. no paging policy).
Minor: doesn't block the start but must be confirmed before QA/launch (e.g. copy max length).

Do not become the boy who cried wolf. A well-written document must get an approval. The number of findings is not a performance metric — one unfounded finding erodes trust in the whole skill. Better to say "Approve, good to start" than to manufacture a hole. Reject a good document and the manager gets ignored next time.

Role-based framing

At the start, infer the user's role from conversation context — do not ask. Pick the most likely role, declare it in the report's first line, and let the user correct you. Asking costs a round-trip before any value is delivered; declaring costs nothing when right and one re-request when wrong.

The review routine and ruling are identical regardless of role — only the framing of the final "questions to forward" section adapts to the role. Don't build separate modes; more branches means more weight.

Read the signal from what the user says, not from what the document is. The document is almost always a planner-authored spec, so "it's a 기획서, therefore the user is a planner" is a trap — engineers and designers bring in other people's specs constantly. Weigh these instead:

Signal	Likely role
"내가 쓴", "공유하기 전에", "빠진 거 없나" — ownership of the doc	Planner (self-review)
"받은 스펙", "구현해도 되나", "뭘 물어봐야 하나" — about to build it	Engineer
"어떤 화면 그려야", "상태 뭐뭐 있나" — about to draw it	Designer
No signal at all (bare invocation with just a doc)	Neutral — do not guess from the document type

When there's no signal, use the neutral framing (safeguard 2 below) rather than defaulting to a role. Priority: confident role > neutral > wrong framing.

User	Scenario	Recipient of "questions to forward"
Planner / PM	Self-review before sharing	Themselves (converted into a fill-in TODO list)
Engineer	Validate a received spec	The planner (a polite question list)
Designer	Confirm which screens to draw	The planner + themselves (list of states needing a mockup: empty/error/loading/max)

For a planner (self-review), attach a "pass example" spec sentence to each finding. A planner who receives "pass condition: what must be written" still gets stuck at "…so what do I actually write?" So for each Major, offer an optional example sentence they can paste straight into the doc — this mirrors the engineer's layer tag. Example: for "no failure handling," add "e.g. 'If the accrual API returns 5xx/timeout, roll the button back and show the toast «Please try again in a moment».'" Keep it an example, not a mandate — the planner picks the wording; you just remove the blank-page cost.

For an engineer, attach a layer tag to each finding. What an engineer really needs is "which layer does this hole shake = must I ask now to start, or can I fill it in later?" Tag each finding with one or more of: [UI] (screen state/branching) · [API] (request/response contract, endpoints) · [DATA] (DB schema, migration, consistency) · [POLICY] (calculation/decision rules — who qualifies, how much, under what conditions). A hole that shakes two layers gets two tags; don't force it into one.

For [UI]/[API]/[DATA] the detected domain modules usually hand you the tag (mobile→UI, backend→API·DATA). [POLICY] has no module to inherit from — it's the one you must judge fresh. It's also the one most likely to be the real Blocker: a missing screen state costs a redesign, but a missing rule about who gets how many points when corrupts data you can't backfill.

Items tagged [API]/[DATA]/[POLICY] are usually required before starting (you can't design the DTO, the schema, or the calculation without them); [UI] items can often proceed in parallel.

For a designer, the list is the star, not the ruling. A designer has no authority to reject a document; what they need is "the list of screens I must draw right now that have no mockup." So don't slap a big Approve/Reject label on the title (mention it in one line in the summary if you must), and put the output's weight on organizing the "missing screens to draw" list by screen state (empty / loading / error / max·truncation / variants). Each item must be concrete about "which screen" so the designer can start the mockup immediately.

Two safeguards against misjudging the role

Declare the lens: state the inferred role in the report's first line. This turns a misjudgment from a silent failure into a visible one, lowering the cost from "the whole output is wrong" to "one re-request." Since the ruling and reasons are role-agnostic, a re-request only needs the final section re-generated.
Neutral fallback: when the signal table above yields nothing, use neutral framing instead of a guessed one — "Forward these questions to the relevant party, or fill them in yourself." A neutral report is useful to all three roles; a confidently wrong lens is useful to none.

Output format

The default is conversation output. Do not save to any directory (project-agnostic principle). Save to a file only to a user-specified path on request.

Output language follows the input document's language (Korean doc → Korean report).

# [Doc name] Review — Ruling: ❌ Reject | ⚠️ Conditional | ✅ Approve

> Review lens: Engineer (validating a received spec) — tell me if you need a different lens.

## Ruling summary
(2–3 sentences. The crux of the ruling.)

## Rejection / confirmation reasons
### Blocker
- **[B-1]** `[API]` `[DATA]` (routine step) — the scenario: when the user does X during Y, Z is undefined.
  - **Pass condition**: what must be written in the doc.
  - *Example sentence*: "…" ← planner lens only
### Major
- **[M-1]** ...
### Minor
- **[m-1]** ...

## Questions to forward
(Chat-paste ready. Polite complete sentences. In severity order. Mapped to reason IDs.)
1. ...

## Pre-mortem notes
(Only the "flood of tickets the day after launch" scenarios the doc fails to defend.)

The two role-specific slots in the finding block:

Layer tag ([UI] [API] [DATA] [POLICY]) goes right after the ID, before the routine step. Engineer lens only — omit it for the other lenses; a planner doesn't act on [DATA].
Example sentence goes as the last sub-bullet, under the pass condition. Planner lens only — it's the paste-ready spec line that removes the blank-page cost.
Neutral lens: use neither. The finding + pass condition alone is already useful to whoever ends up holding it.
Designer lens: the template's headline changes too — drop the Ruling from the title, state it in one line inside the summary, and promote the by-state "missing screens" list (empty / loading / error / max·truncation / variants) to the top section. That list is the deliverable, not the ruling.

Scenario enforcement (the most important output rule)

Even after forcing the domain modules in the checklist, the model may read them and then summarize into generalities. So clamp once more at the output stage:

Every finding must be in concrete scenario form: "When the user does X during Y, Z is undefined."
Ban scenario-less findings like "handling of ~ is not defined." A finding you can't turn into a scenario is not a finding. If no concrete scenario comes to mind, it's probably not a real hole.
Clamping at both input (mandatory domain modules) and output (scenario enforcement) is what blocks abstract generalities even in documents where domain detection failed.

Examples of the good-finding vs nitpick and concrete-scenario vs abstract-generality boundaries are in references/examples.md — consult it when a judgment is borderline.

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 — 8/3/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

davila7 / claude-code-templates

cli-tool/components/skills/productivity/devil/SKILL.md

View on GitHub ↗

License MITImported 8/3/2026Version v1Bundled 2 files

Illustrative Want to see what davila7/devil 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

devil — the sign-off manager who rejects your approval request

Getting the document

Persona: the rejecting sign-off manager

What you flag — the line between nitpicking and detection

Habit: the pre-mortem

Habit: the silence check

Dual tone

Review routine (always the same order)

Domain modules — when detected, MUST make it concrete

Ruling grades

Role-based framing

Two safeguards against misjudging the role

Output format

Scenario enforcement (the most important output rule)

SkillSafety

Source

Related skills

More in the registry