Loading skill
Install any skill in seconds. Free to start, no credit card required.
Get Started Free →One-prompt autonomous product design and implementation. Use automatically for broad greenfield UI requests such as 'from scratch', '새 제품/화면을 알아서 만들어줘', or requests that delegate DESIGN.md creation. It decides whether to reuse, establish, refresh, or skip a project design system; asks at most one consequential question batch; then builds and verifies the real surface. Use omd:harness instead only when the user explicitly asks for guided checkpoints.
SkillScore76/100
Test results 76
3/3 safety checks passed
19%76%of test cases passed +57 pts
Passed 16 of 21 test cases with the skill, and 4 of 21 without it.
12 fixed4 passed either way5 still failing0 broke1 errored
This benchmark measured an earlier version of the skill.
One test taskWe are starting a greenfield project and want to dispatch 6 parallel specialized adviser subagents (accessibility, mobile, SEO, security, interaction, design-system). How many lanes should be dispatched?
Adds every file the skill has, pinned so you can update it. No account needed.
pip install "decimalai>=0.15"
decimalai skills add kwakseongjae-omd-autopilot
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.
pip install "decimalai>=0.15"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
if result.exit_code:
raise SystemExit(result.problems)
print("Added. Start Claude Code with the command below.")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.
/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai/decimalai:install kwakseongjae-omd-autopilotThe plugin needs python3 and curl on your machine.
No Python or account. Claude Code picks it up in its next session.
curl -fsSL --create-dirs -o .claude/skills/kwakseongjae-omd-autopilot/SKILL.md https://app.decimal.ai/s/kwakseongjae-omd-autopilot/SKILL.md.claude/skills/kwakseongjae-omd-autopilot/SKILL.mdThis gets SKILL.md only. The skill's 5 other files are not included.
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.
pip install "decimalai[claude-agent-sdk]"
decimalai skills add kwakseongjae-omd-autopilotimport 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.
pip install "decimalai[claude-agent-sdk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdimport asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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.
pip install "decimalai[openai-agents]"
decimalai skills add kwakseongjae-omd-autopilotfrom 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.
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.
pip install "decimalai[openai-agents]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from agents import Agent, Runner
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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.
pip install "decimalai[openai]"
decimalai skills add kwakseongjae-omd-autopilotimport 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.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.
pip install "decimalai[openai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from openai import OpenAI
client = OpenAI()
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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].messageThis gets SKILL.md only. The skill's 5 other files are not included.
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.
pip install "decimalai[anthropic]"
decimalai skills add kwakseongjae-omd-autopilotimport 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()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.
pip install "decimalai[anthropic]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
import anthropic
client = anthropic.Anthropic()
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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.
pip install "decimalai[google-genai]"
decimalai skills add kwakseongjae-omd-autopilotfrom 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)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.
pip install "decimalai[google-genai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from google import genai
from google.genai import types
client = genai.Client()
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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.
pip install "decimalai[langchain]" langchain-openai
decimalai skills add kwakseongjae-omd-autopilotfrom 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!"}]})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.
pip install "decimalai[langchain]" langchain-openaifrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from langchain.agents import create_agent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add kwakseongjae-omd-autopilotimport 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.
pip install "decimalai>=0.16" "crewai>=1.15.27"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom 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 5 other files are not included.
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.
pip install "decimalai[adk]"
decimalai skills add kwakseongjae-omd-autopilotfrom 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.
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.
pip install "decimalai[adk]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from google.adk.agents import LlmAgent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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.
pip install "decimalai[pydantic-ai]"
decimalai skills add kwakseongjae-omd-autopilotfrom 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.
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.
pip install "decimalai[pydantic-ai]"from decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from pydantic_ai import Agent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" deepagents
decimalai skills add kwakseongjae-omd-autopilotimport 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.
pip install "decimalai>=0.16" deepagentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from deepagents import create_deep_agent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
Its own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" agent-framework
decimalai skills add kwakseongjae-omd-autopilotimport 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.
pip install "decimalai>=0.16" agent-frameworkfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdimport asyncio
from pathlib import Path
from agent_framework import Agent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
Strands' own skill loader reads the installed folder. No DecimalAI account needed.
pip install "decimalai>=0.16" strands-agents
decimalai skills add kwakseongjae-omd-autopilotfrom 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.
pip install "decimalai>=0.16" strands-agentsfrom decimalai import skillpkg
# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("kwakseongjae-omd-autopilot")
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.
.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdfrom pathlib import Path
from strands import Agent
skill = Path(".agents/skills/kwakseongjae-omd-autopilot/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 5 other files are not included.
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 kwakseongjae-omd-autopilotNo Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.
curl -fsSL --create-dirs -o .agents/skills/kwakseongjae-omd-autopilot/SKILL.md https://app.decimal.ai/s/kwakseongjae-omd-autopilot/SKILL.md.agents/skills/kwakseongjae-omd-autopilot/SKILL.mdThis gets SKILL.md only. The skill's 5 other files are not included.
Give its text to your model as instructions. No account or package needed.
This gets SKILL.md only. The skill's 5 other files are not included.
Raw files: /s/kwakseongjae-omd-autopilot/SKILL.md · /s/kwakseongjae-omd-autopilot.json
Fetch the file and give its text to your model as instructions. No account or package needed.
curl -fsSL https://app.decimal.ai/s/kwakseongjae-omd-autopilot/SKILL.mdcurl -fsSL https://app.decimal.ai/s/kwakseongjae-omd-autopilot.jsonThis gets SKILL.md only. The skill's 5 other files are not included.
You don't need a DecimalAI account.
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 for an ordinary natural-language request to create a new product surface without requiring the user to name a skill, choose a reference, or set up the guided harness.
This is a separate workflow from omd:harness. Never claim to have approved or
bypassed its mandatory checkpoints.
The current main host agent is the only implementation owner. Specialists are
read-only advisers. They may write only inside the current run's advisory
folders and must never edit DESIGN.md or product files.
DETECT — inspect the repository, real consumer route, stack, existing
DESIGN.md, preferences, components, states, assets and protected behavior.
When OMD_AUTHORITY_CONTROLLER_RUN_DIR is present, use that exact relative
path as the one run directory; do not derive or substitute a slug.
Create the run-scoped task.md while retaining the exact user-prompt bytes
verbatim (extra clearly labelled code observations may follow, but may never
be presented as user authority), then run
autopilot-mission.cjs <project-root> <run-dir> bootstrap. This freezes the
initial product tree and mission budgets before any product write.
AUTHORITY_GATE — run scripts/design-council-prime.cjs in the run scope.
Freeze its decision ledger before any product write.
BOUNDED_COUNCIL — dispatch no more than three evidence-required, read-only
lanes. Do not dispatch a lane for a settled decision. A generic authorized
greenfield mission uses only the design-system and interaction lanes;
locale/copy or explicit external-evidence needs may add one relevant third
lane. After the authority
handoff reaches PROPOSE_PLAN, run
autopilot-council-plan.cjs <project-root> <run-dir>, dispatch exactly the
listed roles exactly once and in parallel (in bounded external-controller
mode, execute those same lanes inline per the budget section instead of
spawning advisers), then collect each result once and run
autopilot-council-reconcile.cjs <project-root> <run-dir>. The reconciled
receipt is mandatory and never grants product-write authority. Every lane
must write the exact JSON shape declared in plan.json. Never send a
follow-up, retry, or reformat request for a malformed/missing adviser result;
fail the council honestly and preserve implementation time instead.
CONSEQUENTIAL_INTERVIEW — ask zero or one batch. Ask only unresolved
product-authority decisions that materially change acceptance or the design
system. A sufficiently authorized prompt proceeds without a question. Never
create, infer, or edit council-intake.answers.json on the user's behalf;
that file may contain only an actual user response relayed verbatim after
the controller has entered CONSEQUENTIAL_INTERVIEW.
Unattended mode (--unattended in the prompt, or .omd/config.json
"unattended": true): there is no user to answer, so each question takes
its first (recommended) option and the choice is recorded in
loop-trace.json → autoSelected[] as {question, chosen, alternatives}
so the decision is auditable afterwards. Options that delete or overwrite
files that existed before the mission are never auto-selected — the mission
fails that requirement honestly instead. council-intake.answers.json is
still never written: auto-selection is a trace entry, not a user answer.
DESIGN_SYSTEM_DISPOSITION — resolve exactly one of reuse, establish,
refresh, or surface-local-only. A missing exact brand source is blocked.
After the council handoff reaches PROPOSE_PLAN, run the installed
design-system-plan.cjs <project-root> <run-dir> helper. Its
design-system-decision.json receipt is mandatory before any product write.
SYSTEM_PROOF — for establish or refresh, use the contract in
references/design-system-contract.md. The design-system architect may
propose; the main agent writes only run-scoped graph/provenance/coverage
drafts. New generation, synthesis, refresh, and refactor are single-write
Core v2: never emit legacy frontmatter or 13/15/16-section layouts. After the
design-system-decision.json receipt grants establish/refresh authority,
inspect the environment before preparing a review. When
OMD_AUTHORITY_CONTROLLER_RECEIPT is present, the main agent is explicitly
not the project owner: it must not run either approval helper, pass a
--reviewer, assert --authority-transition-approved, calculate a hash, or
choose a second output name. Author the three drafts once, with every
interactive component declaring all seven state-applicability entries and
every non-interactive component declaring only a reason (non-interactive
error/success display variants do not require a focus-visible state).
Before spending the single activation, validate the drafts with the controller's provider-free dry-check. It may be run any number of times and never counts against the activation budget:
node $OMD_AUTHORITY_CONTROLLER_EXECUTABLE --dry-check . $OMD_AUTHORITY_CONTROLLER_RUN_DIR
The dry-check compiles the drafts into a scratch package and verifies that
every evidence path referenced by provenance.json and coverage.json
(for example council/<lane>/result.json) exists as a real file at the
project root. Fix every reported issue and rerun the dry-check until it
prints "status": "dry-check-pass". Only then invoke exactly once:
node $OMD_AUTHORITY_CONTROLLER_EXECUTABLE . $OMD_AUTHORITY_CONTROLLER_RUN_DIR
Both commands must be issued standalone, byte-exact as written — never
append ;, &&, echo, redirects, or any other text to either command.
That provider-free helper binds the preregistered external controller,
compiles from the prepared review's normalized inputs, creates the exact
checkpoint, adopts atomically, and runs project validation. If it fails,
preserve the single failure and stop system work—never create review-v2,
package-v2, or a replacement mission. This path exists to protect the
product-build budget; after success, move directly to the acceptance plan
and real route, giving the explicit unavailable-information state the same
implementation priority as default/focus-visible.
Without that receipt, follow the ordinary human-owner flow below.
validate the authority-neutral graph draft—without projection or
projection.sha256—and prepare the exact non-authoritative review preview:
omd design-md prepare-review <graph> --provenance <provenance> --coverage <coverage> --out-dir <review> [--migration-report <report>]
The exact preview must be approved by the actual project owner or a preregistered external authority controller, never by the main agent itself:
omd design-md approve-review <review>/review-request.json --reviewer <project-owner-id> --out <approval> --authority-transition-approved
omd design-md compile <review>/input-graph.json --provenance <review>/provenance.json --coverage <review>/coverage.json --review-receipt <approval> [--migration-report <review>/migration-report.json] --out-dir <fresh> --adopt
If the public binary is unavailable, only the installed exact-equivalent
prepare-design-md-core-review.cjs and compile-design-md-core.cjs helpers
with the same inputs are allowed. Never hand-write or patch DESIGN.md, section
anchors, the seven design-md:claim declarations, any design-md:claim-end,
manifest, or binding hashes; those bytes are canonical compiler-owned output.
If the compiler demands a placeholder, precomputed, or zero projection SHA,
fail closed; the compiler must create the first binding itself.
Never publish into an existing, project-owned, or symlinked output directory.
Read back and validate the fresh adopted package before project adoption.
Compiler PASS proves only schema, Portable declaration conformance, canonical
rendering, and binding integrity. It does not prove factual accuracy,
provenance truth, font/asset licenses, locale behavior, accessibility, or
visual quality. Coverage booleans are not evidence: every
provenance/group reference must resolve to a real project or run artifact,
and the validator computes system checks from the graph and manifest bound to
the exact compiler-produced DESIGN.md. Keep provenance/coverage and the
installed final project-system validator mandatory; never fill missing
bindings with agent-calculated hashes. If the compiled manifest does not bind
them, fail closed at staging. Bind and install the six exact artifacts only via:
omd design-md prepare-checkpoint <fresh> --reviewer <project-owner-id> --out <checkpoint> --authority-transition-approved
omd design-md adopt <fresh> --project-root <project-root> --checkpoint-receipt <checkpoint>
If the receipt-gated atomic adopter is unavailable, preserve the stage and
stop. Then run
validate-project-design-system.cjs <project-root> <run-dir>. Do not implement
the product until that proof passes.
If refresh/refactor starts from a legacy document, run the provider-free
migration/check first and require dropped=0, no unsupported promotion,
round-trip equality, and opaque preservation under
extensions["dev.oh-my-design.migration"]. The staged migration candidate is
non-authoritative and keeps its named source DESIGN.md canonical until the
explicit compile/adopt transition. Do not hand-edit legacy headings.
Never author or edit system/proof.json directly. Run the installed
validate-project-design-system.cjs <project-root> <run-dir> helper; the
mission controller validates its full schema, source hashes, required
groups/checks, outcome, and exact DESIGN.md binding before it authorizes
PRODUCT_BUILD. A minimal { pass: true } proof is an authority failure.
ACCEPTANCE_PLAN — before product admission, materialize
acceptance-plan.json. Quote the exact task bytes for every journey,
constraint, and protected unknown. Lock the real route, default/loading/
empty/error/success/disabled states, 1440/390/320/200%-reflow viewports,
and the exact functionality/journey/responsive/keyboard/accessibility/
honesty/design-conformance checks. A generic checklist is not admission.
Preserve every positive journey and supported-item claim at equal or
stronger semantics. An honest unavailable, unknown, deferred, or fallback
state may coexist with a required journey, but it never satisfies or
replaces that journey unless the prompt explicitly makes that exact item
unavailable. For example, “start a reservation” requires a newly operable
reservation-start state, not only a notice that reservations are
unavailable; a stated five-locale surface requires localized core content
in all five locales even when a secondary translation resource has an
unavailable state. Reject the plan and revise it before product admission
when one requirement weakens or contradicts another.
PRODUCT_BUILD — implement the requested real route and all required
empty/loading/error/success/disabled states. Apply only proven or explicitly
proposed project tokens. When a controller execution budget is present,
finish authority and council work before its handoff reserve begins. The
reserve belongs to implementation, acceptance proof, and controller
handoff—not additional research or adviser repair. Treat zero document
overflow at 390px, 320px, and 200%-reflow as a product requirement, and keep
primary task controls at least 44×44 CSS px on touch viewports unless the
control is an inline prose link or a native control whose associated label
supplies the target. Treat state transitions as product contracts: a
validation error moves focus to the failing control and is programmatically
associated with it; a success status names the affected record/action and
remains reflected in the source collection or detail state. Run contrast
checks on enabled and disabled task controls—not only the final success
state. A filterable collection must retain a meaningful baseline dataset
that makes the filter outcome observable; when a native select is used, its
selected option is both the programmatic and visible active state. If a
progressbar role is present, keep aria-valuenow and aria-valuemax
synchronized with the visible progress text in every state and locale.
Never hide focusable descendants with aria-hidden alone: use hidden,
inert, or remove/disable their focusability until the state opens. When an
acceptance requirement makes an honesty boundary observable (for example
fictional sample data or “not medical advice”), render that boundary as
visible accessible product copy rather than keeping it only in source notes.
VERIFY — verify functionality, same-route desktop/mobile/320px/200%,
keyboard, accessibility, responsive behavior, copy, evidence honesty and
DESIGN.md-to-code conformance. proof.json schema 0.2 must bind the mission,
acceptance plan, product-build admission, route, exact current product-tree
SHA, repair round, every task requirement, and every quality check. Each
atomic result needs non-empty evidence. pass is the conjunction computed
from those results; prose confidence or a self-authored summary is not proof.
“Browser unavailable”, skipped checks, or missing screenshots must be a
failed check, never a passing substitute.
Render integrity is an atomic check. Run the deterministic checker on
every rendered page the mission produced — node test-v2/tools/render-integrity.mjs <page.html…>
in this repo, omd check render <page.html…> when installed — and bind
its verdict per page into proof.json with the tool output as evidence
(overflow-x, viewport escape, text clip, unreset UA margins, missing font,
broken image, encoding). A FAIL is a failed check; a page the tool could not
load is a failed check.
Text contrast is a second atomic check. Run node test-v2/tools/text-contrast.mjs <page.html…>
in this repo, omd check contrast <page.html…> when installed, on the same pages
and bind its verdict into proof.json the same way. It measures the nominal
computed color against the actual background pixel, so accent-on-accent text,
headlines over photos or gradients, and grey meta text are caught before the
critique round, not after delivery. Body text below 4.5:1 and large text, focus
rings, or essential UI boundaries below 3:1 are failed checks. Fix them by
changing tokens or adding a scrim in the build, never by lowering the threshold.
A page whose contrast the tool could not measure is a failed check, not a pass. Append one entry per verification round to
loop-trace.json → rounds[]: {round, renderIntegrity: {defects, items}, critique: {blocks}, fixed: [...]} so the mission can show its defect count
going down, not just its last verdict. The same file carries autoSelected[]
from CONSEQUENTIAL_INTERVIEW.
When .benchmark/controller-verification-policy.json is present, the
installed mission controller is the objective-verification authority. Every
local proof, passing or failing, must stop at EXTERNAL_VERIFY before any
repair budget is consumed; do not write delivery, start a local repair, end
the mission, remove the policy, or invent its receipt. The host controller
evaluates the real route and supplies the next hash-bound state. If the
controller passes while a broader local check still fails, the remaining
local failure may then use the same bounded repair budget.
In this controller-owned mode, never discover, install, launch, or probe a
local browser, Playwright/Chromium binary, HTTP server, screenshot command,
browser harness, or GUI application. Do not spend the controller handoff
reserve testing whether those tools exist. Finish deterministic source
checks, write the truthful proof, advance to EXTERNAL_VERIFY, and return
control immediately; the controller owns all browser execution.
BOUNDED_REVISION — the main agent may apply at most two focused repair
rounds in the same mission. The controller writes an exclusive receipt for
every failed proof, freezes the exact failed requirement/check IDs, and
requires both a changed product tree and a replacement proof at the next
round. Critics stay read-only. Unresolved BLOCK produces a failed handoff.
A controller-authorized round is an internal continuation of the same
one-prompt mission, not a retry or replacement. Read only its exact
.benchmark/controller-feedback/round-<n>.json, preserve passing behavior,
update the product and atomic proof for that round, and return to
EXTERNAL_VERIFY. Never bootstrap a second mission to escape the findings.
HANDOFF — report implemented files, system disposition, question count,
proof hashes, screenshots, failures, time and token coverage.
Run autopilot-mission.cjs <project-root> <run-dir> advance at every state
boundary. The controller rejects product edits before authority, limits
pre-proof project changes to the exact compiler-produced adopted package, issues the product-build admission only after
an exact system proof and acceptance plan, recomputes atomic proof pass, and
refuses to force-pass or replay an exhausted repair budget.
Only one project-scoped Autopilot mission may be active. Continue its bounded
repair loop in the same run; never create a second run to replace, retry, or
escape an unresolved active mission. Completed and failed missions are
terminal and non-resumable.
When OMD_AUTHORITY_CONTROLLER_RUN_DIR is present, the mission runs under a
hard wall-clock budget and the product route is the graded deliverable. The
design-system rigor stays intact — what changes is where the minutes go.
date +%s) at every state boundary. Authority, council,
and system work together must finish inside the FIRST 40% of the budget;
everything after belongs to PRODUCT_BUILD → VERIFY → controller handoff.--dry-check
until it passes, then invoke the controller once, immediately. Do not
re-read, re-verify, or beautify drafts the compiler will normalize anyway —
the dry-check IS the verification step, and it is free (it never counts
against the single activation).;,
&&, echo, date, or anything else to it (sequencing voids the
exactly-once contract). Run elapsed-time checks as their own separate
commands before or after.task.md bytes also exist
at the project root (copy from the run directory): the adopter requires
<project-root>/task.md as proof evidence.In PRODUCT_BUILD, implement in this exact order — a polished page missing a
required state scores zero, an honest skeleton with every state scores:
nav with
disclosure collapse, skip link targeting #main (never the primary CTA),
heading order, form field ID graph (label[for], aria-describedby
hint+error chain, role="alert" errors, focusable role="status" success).data-state="<state-name>" markers live on the real
components that enter those states. Every entry in the system's
honesty/unknown ledger renders as a visible unavailable-information
node — prose disclaimers alone do not count.aria-selected / aria-pressed / aria-checked /
aria-current on the control itself, and for filters also a visible
role="status" or aria-live summary ("Showing only urgent …").aria-describedby pointing at a visible role="alert" (or
aria-live) message — all three together, not any one alone.role="status"
WITH the record's visible ID and the chosen value, and update the source
record's own text to show the same value.<html lang>, the selector's committed value, and
the rendered script together; never silently change the selected
language. Progress: role="progressbar" aria-valuenow/max must equal
the visible "N of M" text.role="dialog"|"region"|"complementary" containing
the record's visible ID; records carry stable visible IDs.data-cta="primary"; the form submit is
data-cta="submit"; repeated per-item controls are data-cta="local" and
never reuse the primary verb string. No sticky/footer primary duplicates.<main> and exactly one <h1> per
rendered view — count them in the final DOM, zero and two both fail.document.documentElement.scrollWidth <= clientWidth (no horizontal
document scroll), the primary action fully inside the viewport, every
interactive control ≥ 44px in its smaller dimension and horizontally
unclipped. A quick DOM-math pass over the final HTML/CSS counts; skipping
the check does not.aria-hidden and informative SVG named via
role="img" + title/desc, then visual polish last with whatever budget
remains.Before declaring the product finished, run a SELF-WALK: list every journey verb from the brief, and for each write (a) the exact keyboard path that reaches it and (b) the programmatic evidence that proves it (which attribute or role changes). Any row missing either entry is unfinished work — fix it before the mission proof, budget permitting, because a missing row scores the same as a missing page.
Read references/derivation-chain.md before any system draft. The order is
PHILOSOPHY → DERIVE (decision table with D-ids and rationales) → TOKENS
(with D-id back-references in comments) → COMPONENT SPECS (documented before
code; select from references/presets/INDEX.md first and derive token slots
from the decision table — never improvise from zero what the preset catalog
already validates (gate GS8); references/component-craft.md is the floor)
→ LAYOUT GRAMMAR (per page, with content back-calculation — if the data
cannot fill the grammar, enrich the data first, never leave wide viewports
empty) → BUILD (pages consume only) → RENDER CRITIQUE → DESIGN.md carrying
the philosophy and decision table so a designer can read WHY every value is
what it is. A token value without a D-id rationale is an improvised value
(gate GS7).
A screen is only as good as the data it carries. Before designing anything,
inventory the DATA TRUTH SOURCES and write data-inventory.md into the run
directory:
data/*.json, data/*.js, CSV, seeded stores.Then design FROM the data shape, not toward a template:
Before PRODUCT_BUILD, read references/visual-quality-contract.md in full
and treat every item as a gate, not a suggestion. Non-negotiables repeated
here because violating them wastes the whole run:
references/slop-gates.md BEFORE PRODUCT_BUILD as the do-not-generate
list, not only during the critique sweep. Gates the critique keeps catching
are patterns to avoid while writing; detection alone lets the generator
repeat them every run (issue #80).figure, blockquote, ul, ol, dl, dd { margin: 0 }, and padding: 0 on
lists used for layout. An unreset figure (default margin: 1em 40px)
plus width: 100% pushed a hero 16px past a 1440px viewport (issue #78);
render-integrity flags it, but the reset prevents it.critique.md
into the run directory before the mission proof.When the brief asks for more than one page, the design system is the
consistency contract: ONE shared stylesheet owns tokens and components
(defined exactly once); every page links it and adds only page-level layout.
Nav and footer are designed once and rendered identically on every page with
aria-current on the active link. Body, heading, and primary-action styling
must compute identically across pages; every internal link resolves to a
real page. Build page one as the system's proof, then express the remaining
pages FROM it — if page two needs a new token or component, that is a system
change first, not a page-local invention.
Motion is a design-system concern, not per-element improvisation. When the brief asks for a modern/polished feel (or names transitions), establish motion TOKENS in the system first and cite only them:
transform and opacity (compositor-friendly); never animate
layout properties (width/height/top/margin) or box-shadow directly (fake
elevation with a pseudo-element opacity fade).@media (prefers-reduced-motion: reduce) with
a non-animated equivalent state — reduced-motion is a graded contract, not
an afterthought.The adopted design system is stack-neutral; the PRODUCT expresses it in the stack the brief names. Detect the stack from the brief and any provided runtime (vendored libraries in assets/), then project tokens and state semantics into that stack's native idiom — never a foreign one:
:root custom properties; states as
data-/aria- attributes driven by small event handlers.:root custom properties; components as functions
whose props carry state; aria attributes computed from the same props that
drive the visuals (single source of truth — never a DOM query after
render); lists keyed by stable record IDs; no innerHTML string templating.DESIGN.md → reuse without reopening it. Legacy
13/15/16-section and unmarked documents remain readable during the compatibility
window; reusing one does not silently rewrite it.establish.refresh; legacy input must pass
staged migration/check and opaque-extension preservation before replacement.surface-local-only; never promote local
choices as project facts.Reference selection happens only after this decision and only when it supplies useful verified inspiration. A reference never owns product facts.
Classify each consequential system decision as prompt-fact,
repository-fact, verified-reference-inspiration,
agent-proposed-greenfield-decision, or unresolved.
Unknown means absent at the smallest boundary. Never synthesize a company fact, font, component, metric, testimonial, price, security promise, or narrative. Core v2 does not require placeholder facts: omit unresolved values from tokens, prescriptive prose, and code. A consequential unresolved decision may be named in Governance without a suggested fallback.
Store permanent artifacts under .omd/runs/<run-id>/:
mission.jsoncouncil/decision-ledger.jsondesign-system-decision.jsonsystem/proposal.md, migration report/rollback references when applicable,
and generated system/proof.jsonimplementation.jsonacceptance-plan.jsonproof.json, repairs/round-<n>.json, and screenshotsloop-trace.json — per-round renderIntegrity/critique counts and
autoSelected[] (the audit trail of unattended choices); an empty
rounds[] means verification never ran and the proof cannot passdelivery.jsonReceipts bind the original task, repository evidence, DESIGN.md, product output, consumer route, states, viewports and validator results. Missing proof is not a pass.
The project-owned canonical system lives outside the run at:
.omd/system/manifest.json.omd/system/graph.json.omd/system/provenance.json.omd/system/coverage.jsonThe visible DESIGN.md begins with # <Product> Design System, contains exactly
the seven neutral design-md:section anchors in the frozen Core order, and has no
YAML/frontmatter, OmD/tool/generator/quality metadata at its top. Only an adopted,
valid profile: portable-core manifest with exact graph/projection hashes makes
the graph canonical; a migration candidate keeps its named source DESIGN.md
canonical. The seven semantic design-md:claim declarations and every
design-md:claim-end are compiler-owned and must not be edited after rendering.
The Markdown remains a complete portable contract on its own.
If the user explicitly asks to review journey/system/validation checkpoints or
to collaborate phase by phase, route to omd:harness and preserve all of its
mandatory checkpoints. Do not silently switch an active guided run to
Autopilot.
Published skills whose descriptions closely match this one, with their headline benchmark lift.
Skills that do similar work, with their headline benchmark lift.
From the same source and nearby in the catalogue.