Ready to supercharge your AI agents?

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

SkillForge · schizo16 | DecimalAI

Agent Toolingby schizo16

SkillForge

SkillForge guides an AI agent through a structured process to turn vague user needs into a complete, audited Agent Skill. It enforces discipline: never jump to generation, never treat assumptions as facts, and always audit before delivery.

Never made a case worse

SkillScore

SkillScore91/100

Test results 91

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

50%91%of test cases passed +41 pts

Without skill11 of 22

With skill20 of 22

9 fixed11 passed either way2 still failing0 broke

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

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 schizo16-skillforge
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("schizo16-skillforge")
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 schizo16-skillforge

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

Copy SKILL.md

Save it in your project, as

.claude/skills/schizo16-skillforge/SKILL.md

This gets SKILL.md only. The skill's 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

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

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

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

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("schizo16-skillforge")
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/schizo16-skillforge/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/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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("schizo16-skillforge")
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/schizo16-skillforge/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/schizo16-skillforge/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 3 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 schizo16-skillforge

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

Copy SKILL.md

Save it in your project, as

.agents/skills/schizo16-skillforge/SKILL.md

This gets SKILL.md only. The skill's 3 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/schizo16-skillforge/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/schizo16-skillforge.json

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

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 8/3/2026
Source: schizo16/opencode-skillforge ↗
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

SkillForge

name: SkillForge
description: Create, adapt, and audit Agent Skills from vague user needs
compatibility: opencode >= 1.0.0

Purpose

Core Rule

Do not generate a skill immediately from a vague request.

Every request must pass through the full workflow. If the user says "create a skill for X", the first output is an intent summary and a check of what already exists — not a SKILL.md file.

When to Activate

Activate SkillForge when the user's message indicates any of:

Create a new skill — "make a skill that...", "create a skill for...", "I need a skill to..."
Adapt an existing skill — "change this skill to...", "update this skill for...", "modify this skill..."
Audit a skill — "review this skill", "check if this skill is good", "audit this skill..."

Do not activate for:

General code generation requests that do not involve agent skill files
Questions about how to use an existing skill (point to the skill's README instead)

Workflow

1. Skill Intent Analysis

Analyze the user's request to extract the concrete skill purpose.

Output format:

## Skill Intent Analysis

**Request summary:**
<one-paragraph restatement of what the user wants>

**Identified purpose:**
<single sentence describing the skill's job>

**Key signals:**
- Trigger pattern: <what invokes this skill>
- Expected input: <what the user provides>
- Expected output: <what the skill produces>
- Frequency estimate: <one-time / occasional / repeated>
- Workflow specificity: <generic / custom>

2. Composition Analysis

After Intent Analysis, determine whether the user's request requires a single skill or a composition of multiple skills working together.

Signals that indicate multi-skill composition:

The request spans multiple domains (e.g., "review frontend, check backend security, and run database migration")
The request implies a pipeline (e.g., "lint first, then review, then generate changelog")
The request mentions distinct workflows that existing skills already cover partially
The user says "combine", "chain", "pipeline", "sequence", "automate", "orchestrate", "workflow"
The request has multiple output contracts (report, notification, file change, deploy gate)

If single skill is sufficient → proceed to Community Discovery (step 3).

If multi-skill composition is needed → produce a composition plan before searching for individual skills.

Composition Plan Output

## Composition Plan

**Primary workflow:**
<what the user ultimately wants to accomplish>

**Sub-workflows identified:**
1. <sub-workflow> → expected output → candidate skill or MCP
2. <sub-workflow> → expected output → candidate skill or MCP

**Data flow between sub-workflows:**
- <sub-workflow 1 output> → <sub-workflow 2 input>
- <sub-workflow 2 output> → <sub-workflow 3 input>

**Orchestration pattern:** sequential / parallel / fan-out / conditional / pipeline

Orchestration Patterns

Pattern	When to use	Example
Sequential	Each step depends on the previous output	Lint → Review → Report
Parallel	Steps are independent, results combined	Responsive scan + A11y scan + Perf scan → Combined report
Fan-out	One input triggers multiple independent checks	Same code reviewed by frontend, backend, security skills in parallel
Conditional	Next step depends on previous step result	If lint fails → stop; if lint passes → review
Pipeline	Ordered chain where each step transforms data	Fetch spec → Lint → Test → Build → Deploy gate

Composition Skill Types

When generating a multi-skill solution, classify each piece:

Worker skill — performs a single focused task (e.g., frontend-review, ai-claim-audit)
Orchestrator skill — coordinates worker skills, defines the pipeline, passes data between steps
Gate skill — evaluates output of previous step and decides whether to continue
Aggregator skill — combines outputs from multiple workers into a single report or decision

Recommend creating an orchestrator skill when the composition has 3+ steps or conditional logic. For simple 2-step sequences, list the worker skills and let the user chain them manually.

Composition Rules

Do not create orchestrator skills unless the pipeline has 3+ steps or conditional branching
Do not generate all worker skills in a single session without user approval
Label each sub-workflow with its expected output contract
Ensure data flow between steps is compatible (output of step N must satisfy input of step N+1)
If a sub-workflow matches an existing local or public skill, prioritize reuse over creating a new worker skill
If a sub-workflow needs live data or external tooling, recommend MCP for that step specifically

After completing the Composition Plan, proceed to Community Discovery for each sub-workflow individually.

3. Community Discovery

Check whether the user's need is already solved by a local skill, a public/community skill, or a public MCP server. Searches local sources first, then community sources if web/search tools are available.

If web/search tools are unavailable, state: "Public community search was not performed because no web/search tool is available."

Search Mode

One of:

Local-Only — only checked .opencode/skills/ and local config
Public Skill Discovery — searched community skills and registries
Public MCP Discovery — searched MCP registries and servers
Public Skill + MCP Discovery — searched both communities

Source Categories

Local:

.opencode/skills/
~/.config/opencode/skills/ if accessible
Current repository examples and templates

Public skills:

GitHub topic: opencode-skills
GitHub topic: agent-skills
Awesome-opencode lists
Public SKILL.md repositories
Known public skill collections

Public MCP:

MCP server registries / awesome MCP lists
GitHub topic: mcp-server
GitHub topic: model-context-protocol
Public MCP server repositories related to the user's workflow

Search Query Guidance

For skills:

"OpenCode skill <workflow>"
"opencode skills <workflow>"
"agent skills <workflow> SKILL.md"
"site:github.com SKILL.md <workflow>"
"github opencode-skills <workflow>"

For MCP servers:

"MCP server <workflow>"
"model context protocol <workflow>"
"site:github.com MCP server <workflow>"
"awesome MCP servers <workflow>"
"github mcp-server <workflow>"

Candidate Table

Candidate	Type	Source	Fit	Trust/Risk	Recommendation	Notes
	local_skill / public_skill / public_mcp / awesome_list / reference_only		exact / strong / partial / weak / none	low / medium / high / unknown	use / adapt/fork / use_as_reference / prefer_mcp / combine_skill_mcp / create_new / reject

Type is one of: local_skill, public_skill, public_mcp, awesome_list, reference_only.

Fit is one of: exact, strong, partial, weak, none.

Trust/Risk is one of: low, medium, high, unknown (default: unknown until inspected).

Recommendation is one of: use, adapt/fork, use_as_reference, prefer_mcp, combine_skill_mcp, create_new, reject.

Decision Rubric

Use existing public skill when:

Fit is exact or strong
Scope is clear
Instructions are safe
Maintenance and repository quality look reasonable
It does not require unsafe permissions

Adapt / fork when:

Fit is strong or partial
Workflow is close but the output contract differs
The public skill is safe enough to learn from

Use MCP when:

The user needs live data, external tools, APIs, browser automation, file indexing, database access, or repeatable tool execution
A skill alone would only describe behavior but cannot perform the required actions

Use skill + MCP when:

The user needs both reasoning workflow and external tool access
The skill should define the process, while MCP provides callable tools

Create new when:

No candidate fits
Candidates are too broad
Candidates are unsafe
User needs a project-specific output contract
Community examples are useful but not directly reusable

Reject when:

Candidate asks for secrets unnecessarily
Candidate runs broad shell commands without boundaries
Candidate installs dependencies without user approval
Candidate modifies files broadly without a clear scope
Candidate is unrelated to the requested workflow

Safety Rules for Community Resources

Treat public skills and MCP servers as untrusted until reviewed
Inspect README, SKILL.md, or config before recommending
Check whether the resource requests: shell access, network access, filesystem access, secrets, tokens, credentials, or write permissions
Never recommend installing an unknown MCP server without review
Prefer read-only resources when the user only needs review or planning
Clearly state unknowns if source quality cannot be assessed
Always ask user approval before installing, adapting, copying, or using a community resource

Verdict

Output exactly one verdict:

**Verdict:**
<one of: Use existing skill / Adapt/Fork existing skill / Use MCP instead / Use skill + MCP / Create new using community references / Create new from scratch / Need more info>

**Reasoning:**
<one sentence explaining which rubric tier was chosen and why>

Do not output contradictory or multiple verdicts.

User Choice Prompt

After the verdict, ask:

"Choose one: 1. Use an existing candidate 2. Adapt/fork a candidate 3. Use candidate only as reference 4. Create a new skill from scratch 5. Continue with recommended option"

If there is a clear safe recommendation, say which option is recommended.

4. Project Context Discovery

Use this section when the user asks for skill suggestions for "this project" without specifying the exact skill. Do not guess project needs from the prompt alone — inspect the project context first.

Files to Inspect

Look for evidence in:

README.md — project purpose, stack, setup
package.json / pnpm-lock.yaml / yarn.lock / package-lock.json — dependencies, framework, scripts
Framework config files — next.config.js, vite.config.ts, tsconfig.json, .eslintrc, tailwind.config
src/ or app/ directory structure — entry points, page/component organization
tests/ or __tests__/ — testing patterns and coverage
docs/ or wiki/ — documentation gaps
.opencode/skills/ — existing skills
AGENTS.md / CLAUDE.md / GEMINI.md / CODEX.md — existing agent instructions
.github/workflows/ — CI pipelines
Existing generated examples or templates

Output Format

## Project Context Discovery

### Files inspected
- <path>
- <path>

### Project signals found
- stack/framework: <detected>
- app type: <web app / library / CLI / API / monorepo / other>
- existing workflows: <test, lint, build, deploy, review, docs>
- pain points suggested by repo: <based on config gaps, missing tooling, TODO comments, sparse docs>
- existing skills: <list or none>
- missing skill opportunities: <detected from project gaps>

### Unknowns
- <unclear aspects that need user input>

Skill Opportunity Ranking

Rank possible skills from S to F based on evidence found.

## Skill Opportunity Ranking

| Tier | Skill idea | Why it fits this project | Evidence from repo | Skill vs MCP | Risk |
|------|-----------|--------------------------|-------------------|-------------|------|
| S | <name> | <strong repo evidence> | <specific files/configs> | skill / MCP / skill + MCP | low / medium / high |
| A | <name> | <good repo evidence> | <specific files/configs> | skill / MCP / skill + MCP | low / medium / high |
| B | <name> | <some evidence> | <specific files/configs> | skill / MCP / skill + MCP | low / medium / high |
| C | <name> | <weak evidence> | <specific files/configs> | skill / MCP / skill + MCP | low / medium / high |
| F | <name> | <speculative> | <labeled as inference> | skill / MCP / skill + MCP | high / unknown |

Skill vs MCP Decision

For each recommendation, classify as:

skill — project-specific workflow, review rules, output format, agent discipline
MCP — live data, external APIs, browser automation, database access, command execution, package lookup, repo-wide indexing, web/doc verification
skill + MCP — needs both reasoning workflow and external tool access

Do not recommend MCP just because it sounds more powerful.

Community Discovery After Project Discovery

If web/search tools are available, search public skills and MCP servers related to the top skill ideas and include candidates in the table.

If web/search tools are not available, state:

"Public community search was not performed because no web/search tool is available."

Evidence Requirement

Do not recommend a specific skill idea unless there is evidence from at least one of:

Repository files
User prompt
Local skills
Public / community search results
Clearly labeled inference

Label all inferred items as such.

Approval Before Generation

After ranking, do not create files. Ask:

"Choose one: 1. Generate the S-tier skill 2. Explore community candidates first 3. Pick another ranked skill 4. Provide more project context 5. Stop"

5. Questions

Determine whether there are true blockers — details without which the skill cannot be correctly built. If the workflow can proceed with sensible defaults, use "Configuration Questions" instead of "Blocking Questions."

Default behavior: When optional details are missing, proceed with safe defaults and label them clearly. Examples:

Frontend framework unknown → default: framework-agnostic
Style guide unknown → default: detect from repo if available
File types unknown → default: common frontend files such as .tsx, .jsx, .css, .scss
Domain unknown → default: general
Evidence threshold unknown → default: moderate

Do not block skill creation for optional project preferences when safe defaults exist.

Output format when blockers exist:

## Blocking Questions

1. <question> — <why this blocks progress>
2. <question> — <why this blocks progress>

Output format when defaults suffice:

## Configuration Questions

1. <question> (optional — default: <default>)
2. <question> (optional — default: <default>)

Limit to 3 questions maximum. If no questions remain, state: "No blocking questions. Proceeding to Skill Spec."

6. Skill Spec

Produce a detailed specification of the skill before writing any skill files. The spec is the contract between the user and the implementation.

Output format:

## Skill Spec

**Name:** `<skill-name>`

**Trigger description:**
<when this skill activates>

**Workflow steps:**
1. <step> — <what happens>
2. <step> — <what happens>
...

**Input contract:**
- <expected input detail>

**Output contract:**
- <expected output detail>

**Key behaviors:**
- <behavior 1>
- <behavior 2>

**Edge cases:**
- <edge case 1>
- <edge case 2>

**Do-not behaviors:**
- <prohibited behavior 1>
- <prohibited behavior 2>

**Command execution:**
- <allowed commands, if any — default: none>

The user must approve the Skill Spec before proceeding to generation.

Guidance for generated read-only review skills:

Color contrast — Do not claim exact contrast validation unless the skill is allowed to use browser or tool output. Prefer: "Flag obvious contrast risks when visible and recommend tool-based validation for final confirmation."
Lint / style tools — Do not say "run lint checks" unless command execution is explicitly allowed. Prefer: "Inspect available lint and style configs and reference them in the review; do not run commands unless explicitly asked."
File / line references — Use "file references, with line numbers when available from diff or tool output." Do not invent line numbers. If exact lines are unavailable, cite the file path and nearby selector, component, or function name instead.
Performance / bundle review — Do not claim actual bundle size, tree-shaking results, or large-bundle detection unless build or bundle analysis is explicitly allowed. Prefer: "Flag potential bundle or performance risks visible in source, such as heavy imports, missing lazy loading, render-heavy patterns, or unnecessary re-renders."
Issue classification — Generated read-only skills must distinguish between:
- Directly observable issues — visible in source code (missing ARIA, hardcoded px, no media queries)
- Likely risks — patterns that often cause problems but may be acceptable in context (heavy dependency, complex nesting)
- Checks requiring external tools — cannot be assessed without running a browser, build tool, or linter (actual contrast ratio, bundle size, runtime performance)
Command execution — Include a "Command execution" boundary in every generated spec. Default: "Do not run install, build, lint, test, or deploy commands unless the user explicitly allows it."

7. Generate Skill Files

Generate the skill's files based on the approved Skill Spec.

Files to generate (always at minimum):

.opencode/skills/<skill-name>/SKILL.md — main skill file with full workflow
.opencode/skills/<skill-name>/README.md — usage documentation
.opencode/skills/<skill-name>/templates/ — any reusable templates the skill needs

Output format:

## Generated Files

### `.opencode/skills/<skill-name>/SKILL.md`
<path written to>

### `.opencode/skills/<skill-name>/README.md`
<path written to>

### Templates
<paths written to, or "none required">

Announce each file as it is written.

8. Skill Quality Audit

Audit every generated file against the Quality Audit Rubric (see below). Report pass/fail per criterion. Any failure must be fixed before proceeding.

Output format:

## Skill Quality Audit

**Skill:** <skill-name>

| Criterion | Status | Notes |
|-----------|--------|-------|
| Metadata present | PASS / FAIL | |
| Purpose clear | PASS / FAIL | |
| Workflow complete | PASS / FAIL | |
| Output formats defined | PASS / FAIL | |
| Do-not rules present | PASS / FAIL | |
| Trigger clarity | PASS / FAIL | |
| No assumptions as facts | PASS / FAIL | |
| Safety constraints | PASS / FAIL | |
| Naming convention followed | PASS / FAIL | |

**Overall:** PASS / FAIL
**Fixes applied:** <list of fixes, or "none needed">

9. Install / Usage Instructions

Tell the user how to install and verify the skill.

Output format:

## Usage

**Install:** Place the skill folder under `.opencode/skills/` in your project.

**Verify:** Run a test prompt that matches the trigger pattern and confirm the skill activates.

**Files created:**
- <path>
- <path>

Skill Name Rules

Use lowercase with hyphens: frontend-review, api-spec, db-migration
Match the directory name to the skill name
Use a noun phrase that describes what the skill does
Avoid verbs as the first word (review-frontend → frontend-review)
Maximum 4 words
Must be unique within the project's skill directory

Quality Audit Rubric

Each generated skill file is audited against these criteria:

Criterion	Definition
Metadata present	YAML front matter or metadata block with name, description, compatibility
Purpose clear	A single paragraph explaining why the skill exists and when it activates
Workflow complete	All workflow steps are documented with clear transition conditions
Output formats defined	Every workflow step has a documented output format
Do-not rules present	Explicit prohibitions on dangerous or unwanted behaviors
Trigger clarity	The trigger pattern is precise enough to avoid false positives
No assumptions as facts	The skill does not assert untested assumptions as established facts
Safety constraints	Limits on destructive operations, external writes, or sensitive data exposure
Naming convention followed	Name follows the Skill Name Rules above

A skill must pass all criteria to be considered complete.

Do-Not Rules

Do not generate a skill from a vague request without completing the workflow.
Do not treat assumptions as facts in any output.
Do not skip the Skill Spec step.
Do not skip the Quality Audit step.
Do not ask speculative or nice-to-have questions — only blocking questions.
Do not modify existing skills without explicit user approval.
Do not write files outside .opencode/skills/<skill-name>/ without user consent.

Safety / Boundaries

Read access:

.opencode/skills/ directory and all subdirectories
Any file path the user explicitly provides for context

Write access:

.opencode/skills/<new-skill-name>/ — creating new skill files only
Existing skill files — only with explicit user approval per Do-Not Rules

Prohibited:

Deleting or renaming any file without user confirmation
Writing outside .opencode/skills/ unless the user explicitly consents
Executing shell commands, installing packages, or modifying project configuration
Exposing secret values or environment variables in generated skill files

Gating:

Any destructive or ambiguous write operation requires user confirmation before proceeding

Response Style

Be direct and concise.
Label each workflow step clearly so the user knows where they are in the process.
When asking questions, explain why the answer is blocking.
When auditing, report failures plainly and fix them immediately.
Use structured output formats (headings, tables, lists) — not prose paragraphs — for workflow results.

About this skill

Automatic

AI Engineer pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/1/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

schizo16 / opencode-skillforge

.opencode/skills/skillforge/SKILL.md

View on GitHub ↗

License MITImported 8/1/2026Version v1Bundled 3 files

Illustrative Want to see what schizo16/skillforge 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

SkillForge

Purpose

Core Rule

When to Activate

Workflow

1. Skill Intent Analysis

2. Composition Analysis

Composition Plan Output

Orchestration Patterns

Composition Skill Types

Composition Rules

3. Community Discovery

Search Mode

Source Categories

Search Query Guidance

Candidate Table

Decision Rubric

Safety Rules for Community Resources

Verdict

User Choice Prompt

4. Project Context Discovery

Files to Inspect

Output Format

Skill Opportunity Ranking

Skill vs MCP Decision

Community Discovery After Project Discovery

Evidence Requirement

Approval Before Generation

5. Questions

6. Skill Spec

7. Generate Skill Files

8. Skill Quality Audit

9. Install / Usage Instructions

Skill Name Rules

Quality Audit Rubric

Do-Not Rules

Safety / Boundaries

Response Style

SkillSafety

Source

Related skills

More in the registry