Ready to supercharge your AI agents?

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

Scientific Writing · mkurman | DecimalAI

Researchby mkurman

Scientific Writing

Core skill for the deep research and writing tool. Write scientific manuscripts in full paragraphs (never bullet points). Use two-stage process with (1) section outlines with key points using research-lookup then (2) convert to flowing prose. IMRAD structure, citations (APA/AMA/Vancouver), figures/tables, reporting guidelines (CONSORT/STROBE/PRISMA), for research papers and journal submissions.

Never made a case worseMaintained

SkillScore

SkillScore87/100

Test results 87

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

65%87%of test cases passed +22 pts

Without skill15 of 23

With skill20 of 23

5 fixed15 passed either way3 still failing0 broke

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

Track record

Agent runs: 0; All time

See one task, with and without the skill

One test taskFormat a LaTeX table row for an internal research report reporting a mean score of 42.5 with a standard deviation of 8.3, sample size of 250, and a 95% confidence interval from 0.45 to 0.72 using standard report macros.

Without the skillMissed

With the skillPassed

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

Use this skill

Your agent runs on

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

pip install "decimalai>=0.15"
decimalai skills add mkurman-scientific-writing
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("mkurman-scientific-writing")
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 mkurman-scientific-writing

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/mkurman-scientific-writing/SKILL.md https://app.decimal.ai/s/mkurman-scientific-writing/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/mkurman-scientific-writing/SKILL.md

This gets SKILL.md only. The skill's 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/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/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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("mkurman-scientific-writing")
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/mkurman-scientific-writing/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/mkurman-scientific-writing/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 9 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 mkurman-scientific-writing

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/mkurman-scientific-writing/SKILL.md https://app.decimal.ai/s/mkurman-scientific-writing/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/mkurman-scientific-writing/SKILL.md

This gets SKILL.md only. The skill's 9 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/mkurman-scientific-writing/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/mkurman-scientific-writing.json

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

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 8/21/2026
Source: mkurman/zorai ↗
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

--------|---------|-------------| | Research Papers | 5 | 6-8 | | Literature Reviews | 4 | 5-7 | | Market Research | 20 | 25-30 | | Presentations | 1/slide | 1-2/slide | | Posters | 6 | 8-10 | | Grants | 4 | 5-7 | | Clinical Reports | 3 | 4-6 |

Use scientific-schematics EXTENSIVELY for technical diagrams:

python scripts/generate_schematic.py "your diagram description" -o figures/output.png

Study design and methodology flowcharts (CONSORT, PRISMA, STROBE)
Conceptual framework diagrams
Experimental workflow illustrations
Data analysis pipeline diagrams
Biological pathway or mechanism diagrams
System architecture visualizations
Neural network architectures
Decision trees, algorithm flowcharts
Comparison matrices, timeline diagrams
Any technical concept that benefits from schematic visualization

Use generate-image EXTENSIVELY for visual content:

python scripts/generate_image.py "your image description" -o figures/output.png

Photorealistic illustrations of concepts
Medical/anatomical illustrations
Environmental/ecological scenes
Equipment and lab setup visualizations
Artistic visualizations, infographics
Cover images, header graphics
Product mockups, prototype visualizations
Any visual that enhances understanding or engagement

The AI will automatically:

Create publication-quality images with proper formatting
Review and refine through multiple iterations
Ensure accessibility (colorblind-friendly, high contrast)
Save outputs in the figures/ directory

When in Doubt, Generate a Figure:

Complex concept → generate a schematic
Data discussion → generate a visualization
Process description → generate a flowchart
Comparison → generate a comparison diagram
Reader benefit → generate a visual

For detailed guidance, refer to the scientific-schematics and generate-image skill documentation.

Core Capabilities

1. Manuscript Structure and Organization

IMRAD Format: Guide papers through the standard Introduction, Methods, Results, And Discussion structure used across most scientific disciplines. This includes:

Introduction: Establish research context, identify gaps, state objectives
Methods: Detail study design, populations, procedures, and analysis approaches
Results: Present findings objectively without interpretation
Discussion: Interpret results, acknowledge limitations, propose future directions

For detailed guidance on IMRAD structure, refer to references/imrad_structure.md.

Alternative Structures: Support discipline-specific formats including:

Review articles (narrative, systematic, scoping)
Case reports and case series
Meta-analyses and pooled analyses
Theoretical/modeling papers
Methods papers and protocols

2. Section-Specific Writing Guidance

Abstract Composition: Craft concise, standalone summaries (100-250 words) that capture the paper's purpose, methods, results, and conclusions. Support both structured abstracts (with labeled sections) and unstructured single-paragraph formats.

Introduction Development: Build compelling introductions that:

Establish the research problem's importance
Review relevant literature systematically
Identify knowledge gaps or controversies
State clear research questions or hypotheses
Explain the study's novelty and significance

Methods Documentation: Ensure reproducibility through:

Detailed participant/sample descriptions
Clear procedural documentation
Statistical methods with justification
Equipment and materials specifications
Ethical approval and consent statements

Results Presentation: Present findings with:

Logical flow from primary to secondary outcomes
Integration with figures and tables
Statistical significance with effect sizes
Objective reporting without interpretation

Discussion Construction: Synthesize findings by:

Relating results to research questions
Comparing with existing literature
Acknowledging limitations honestly
Proposing mechanistic explanations
Suggesting practical implications and future research

3. Citation and Reference Management

Apply citation styles correctly across disciplines. For comprehensive style guides, refer to references/citation_styles.md.

Major Citation Styles:

AMA (American Medical Association): Numbered superscript citations, common in medicine
Vancouver: Numbered citations in square brackets, biomedical standard
APA (American Psychological Association): Author-date in-text citations, common in social sciences
Chicago: Notes-bibliography or author-date, humanities and sciences
IEEE: Numbered square brackets, engineering and computer science

Best Practices:

Cite primary sources when possible
Include recent literature (last 5-10 years for active fields)
Balance citation distribution across introduction and discussion
Verify all citations against original sources
Use reference management software (Zotero, Mendeley, EndNote)

4. Figures and Tables

Create effective data visualizations that enhance comprehension. For detailed best practices, refer to references/figures_tables.md.

When to Use Tables vs. Figures:

Tables: Precise numerical data, complex datasets, multiple variables requiring exact values
Figures: Trends, patterns, relationships, comparisons best understood visually

Design Principles:

Make each table/figure self-explanatory with complete captions
Use consistent formatting and terminology across all display items
Label all axes, columns, and rows with units
Include sample sizes (n) and statistical annotations
Follow the "one table/figure per 1000 words" guideline
Avoid duplicating information between text, tables, and figures

Common Figure Types:

Bar graphs: Comparing discrete categories
Line graphs: Showing trends over time
Scatterplots: Displaying correlations
Box plots: Showing distributions and outliers
Heatmaps: Visualizing matrices and patterns

5. Reporting Guidelines by Study Type

Ensure completeness and transparency by following established reporting standards. For comprehensive guideline details, refer to references/reporting_guidelines.md.

Key Guidelines:

CONSORT: Randomized controlled trials
STROBE: Observational studies (cohort, case-control, cross-sectional)
PRISMA: Systematic reviews and meta-analyses
STARD: Diagnostic accuracy studies
TRIPOD: Prediction model studies
ARRIVE: Animal research
CARE: Case reports
SQUIRE: Quality improvement studies
SPIRIT: Study protocols for clinical trials
CHEERS: Economic evaluations

Each guideline provides checklists ensuring all critical methodological elements are reported.

6. Writing Principles and Style

Apply fundamental scientific writing principles. For detailed guidance, refer to references/writing_principles.md.

Clarity:

Use precise, unambiguous language
Define technical terms and abbreviations at first use
Maintain logical flow within and between paragraphs
Use active voice when appropriate for clarity

Conciseness:

Eliminate redundant words and phrases
Favor shorter sentences (15-20 words average)
Remove unnecessary qualifiers
Respect word limits strictly

Accuracy:

Report exact values with appropriate precision
Use consistent terminology throughout
Distinguish between observations and interpretations
Acknowledge uncertainty appropriately

Objectivity:

Present results without bias
Avoid overstating findings or implications
Acknowledge conflicting evidence
Maintain professional, neutral tone

7. Writing Process: From Outline to Full Paragraphs

CRITICAL: Always write in full paragraphs, never submit bullet points in scientific papers.

Scientific papers must be written in complete, flowing prose. Use this two-stage approach for effective writing:

Stage 1: Create Section Outlines with Key Points

When starting a new section:

Use the research-lookup skill to gather relevant literature and data
Create a structured outline with bullet points marking:
- Main arguments or findings to present
- Key studies to cite
- Data points and statistics to include
- Logical flow and organization
These bullet points serve as scaffolding—they are NOT the final manuscript

Example outline (Introduction section):

- Background: AI in drug discovery gaining traction
  * Cite recent reviews (Smith 2023, Jones 2024)
  * Traditional methods are slow and expensive
- Gap: Limited application to rare diseases
  * Only 2 prior studies (Lee 2022, Chen 2023)
  * Small datasets remain a challenge
- Our approach: Transfer learning from common diseases
  * Novel architecture combining X and Y
- Study objectives: Validate on 3 rare disease datasets

Stage 2: Convert Key Points to Full Paragraphs

Once the outline is complete, expand each bullet point into proper prose:

Transform bullet points into complete sentences with subjects, verbs, and objects
Add transitions between sentences and ideas (however, moreover, in contrast, subsequently)
Integrate citations naturally within sentences, not as lists
Expand with context and explanation that bullet points omit
Ensure logical flow from one sentence to the next within each paragraph
Vary sentence structure to maintain reader engagement

Example conversion to prose:

Artificial intelligence approaches have gained significant traction in drug discovery 
pipelines over the past decade (Smith, 2023; Jones, 2024). While these computational 
methods show promise for accelerating the identification of therapeutic candidates, 
traditional experimental approaches remain slow and resource-intensive, often requiring 
years of laboratory work and substantial financial investment. However, the application 
of AI to rare diseases has been limited, with only two prior studies demonstrating 
proof-of-concept results (Lee, 2022; Chen, 2023). The primary obstacle has been the 
scarcity of training data for conditions affecting small patient populations. 

To address this challenge, we developed a transfer learning approach that leverages 
knowledge from well-characterized common diseases to predict therapeutic targets for 
rare conditions. Our novel neural architecture combines convolutional layers for 
molecular feature extraction with attention mechanisms for protein-ligand interaction 
modeling. The objective of this study was to validate our approach across three 
independent rare disease datasets, assessing both predictive accuracy and biological 
interpretability of the results.

Key Differences Between Outlines and Final Text:

Outline (Planning Stage)	Final Manuscript
Bullet points and fragments	Complete sentences and paragraphs
Telegraphic notes	Full explanations with context
List of citations	Citations integrated into prose
Abbreviated ideas	Developed arguments with transitions
For your eyes only	For publication and peer review

Common Mistakes to Avoid:

❌ Never leave bullet points in the final manuscript
❌ Never submit lists where paragraphs should be
❌ Don't use numbered or bulleted lists in Results or Discussion sections (except for specific cases like study hypotheses or inclusion criteria)
❌ Don't write sentence fragments or incomplete thoughts
✅ Do use occasional lists only in Methods (e.g., inclusion/exclusion criteria, materials lists)
✅ Do ensure every section flows as connected prose
✅ Do read paragraphs aloud to check for natural flow

When Lists ARE Acceptable (Limited Cases):

Lists may appear in scientific papers only in specific contexts:

Methods: Inclusion/exclusion criteria, materials and reagents, participant characteristics
Supplementary Materials: Extended protocols, equipment lists, detailed parameters
Never in: Abstract, Introduction, Results, Discussion, Conclusions

Abstract Format Rule:

❌ NEVER use labeled sections (Background:, Methods:, Results:, Conclusions:)
✅ ALWAYS write as flowing paragraph(s) with natural transitions
Exception: Only use structured format if journal explicitly requires it in author guidelines

Integration with Research Lookup:

The research-lookup skill is essential for Stage 1 (creating outlines):

Search for relevant papers using research-lookup
Extract key findings, methods, and data
Organize findings as bullet points in your outline
Then convert the outline to full paragraphs in Stage 2

This two-stage process ensures you:

Gather and organize information systematically
Create logical structure before writing
Produce polished, publication-ready prose
Maintain focus on the narrative flow

8. Professional Report Formatting (Non-Journal Documents)

For research reports, technical reports, white papers, and other professional documents that are NOT journal manuscripts, use the scientific_report.sty LaTeX style package for a polished, professional appearance.

When to Use Professional Report Formatting:

Research reports and technical reports
White papers and policy briefs
Grant reports and progress reports
Industry reports and technical documentation
Internal research summaries
Feasibility studies and project deliverables

When NOT to Use (Use Venue-Specific Formatting Instead):

Journal manuscripts → Use venue-templates skill
Conference papers → Use venue-templates skill
Academic theses → Use institutional templates

The scientific_report.sty Style Package Provides:

Feature	Description
Typography	Helvetica font family for modern, professional appearance
Color Scheme	Professional blues, greens, and accent colors
Box Environments	Colored boxes for key findings, methods, recommendations, limitations
Tables	Alternating row colors, professional headers
Figures	Consistent caption formatting
Scientific Commands	Shortcuts for p-values, effect sizes, confidence intervals

Box Environments for Content Organization:

% Key findings (blue) - for major discoveries
\begin{keyfindings}[Title]
Content with key findings and statistics.
\end{keyfindings}

% Methodology (green) - for methods highlights
\begin{methodology}[Study Design]
Description of methods and procedures.
\end{methodology}

% Recommendations (purple) - for action items
\begin{recommendations}[Clinical Implications]
\begin{enumerate}
    \item Specific recommendation 1
    \item Specific recommendation 2
\end{enumerate}
\end{recommendations}

% Limitations (orange) - for caveats and cautions
\begin{limitations}[Study Limitations]
Description of limitations and their implications.
\end{limitations}

Professional Table Formatting:

\begin{table}[htbp]
\centering
\caption{Results Summary}
\begin{tabular}{@{}lccc@{}}
\toprule
\textbf{Variable} & \textbf{Treatment} & \textbf{Control} & \textbf{p} \\
\midrule
Outcome 1 & \meansd{42.5}{8.3} & \meansd{35.2}{7.9} & <.001\sigthree \\
\rowcolor{tablealt} Outcome 2 & \meansd{3.8}{1.2} & \meansd{3.1}{1.1} & .012\sigone \\
Outcome 3 & \meansd{18.2}{4.5} & \meansd{17.8}{4.2} & .58\signs \\
\bottomrule
\end{tabular}

{\small \siglegend}
\end{table}

Scientific Notation Commands:

Command	Output	Purpose
`\pvalue{0.023}`	p = 0.023	P-values
`\psig{< 0.001}`	p = < 0.001	Significant p-values (bold)
`\CI{0.45}{0.72}`	95% CI [0.45, 0.72]	Confidence intervals
`\effectsize{d}{0.75}`	d = 0.75	Effect sizes
`\samplesize{250}`	n = 250	Sample sizes
`\meansd{42.5}{8.3}`	42.5 ± 8.3	Mean with SD
`\sigone`, `\sigtwo`, `\sigthree`	, , **	Significance stars

Getting Started:

\documentclass[11pt,letterpaper]{report}
\usepackage{scientific_report}

\begin{document}
\makereporttitle
    {Report Title}
    {Subtitle}
    {Author Name}
    {Institution}
    {Date}

% Your content with professional formatting
\end{document}

Compilation: Use XeLaTeX or LuaLaTeX for proper Helvetica font rendering:

xelatex report.tex

For complete documentation, refer to:

assets/scientific_report.sty: The style package
assets/scientific_report_template.tex: Complete template example
assets/REPORT_FORMATTING_GUIDE.md: Quick reference guide
references/professional_report_formatting.md: Comprehensive formatting guide

9. Journal-Specific Formatting

Adapt manuscripts to journal requirements:

Follow author guidelines for structure, length, and format
Apply journal-specific citation styles
Meet figure/table specifications (resolution, file formats, dimensions)
Include required statements (funding, conflicts of interest, data availability, ethical approval)
Adhere to word limits for each section
Format according to template requirements when provided

10. Field-Specific Language and Terminology

Adapt language, terminology, and conventions to match the specific scientific discipline. Each field has established vocabulary, preferred phrasings, and domain-specific conventions that signal expertise and ensure clarity for the target audience.

Identify Field-Specific Linguistic Conventions:

Review terminology used in recent high-impact papers in the target journal
Note field-specific abbreviations, units, and notation systems
Identify preferred terms (e.g., "participants" vs. "subjects," "compound" vs. "drug," "specimens" vs. "samples")
Observe how methods, organisms, or techniques are typically described

Biomedical and Clinical Sciences:

Use precise anatomical and clinical terminology (e.g., "myocardial infarction" not "heart attack" in formal writing)
Follow standardized disease nomenclature (ICD, DSM, SNOMED-CT)
Specify drug names using generic names first, brand names in parentheses if needed
Use "patients" for clinical studies, "participants" for community-based research
Follow Human Genome Variation Society (HGVS) nomenclature for genetic variants
Report lab values with standard units (SI units in most international journals)

Molecular Biology and Genetics:

Use italics for gene symbols (e.g., TP53), regular font for proteins (e.g., p53)
Follow species-specific gene nomenclature (uppercase for human: BRCA1; sentence case for mouse: Brca1)
Specify organism names in full at first mention, then use accepted abbreviations (e.g., Escherichia coli, then E. coli)
Use standard genetic notation (e.g., +/+, +/-, -/- for genotypes)
Employ established terminology for molecular techniques (e.g., "quantitative PCR" or "qPCR," not "real-time PCR")

Chemistry and Pharmaceutical Sciences:

Follow IUPAC nomenclature for chemical compounds
Use systematic names for novel compounds, common names for well-known substances
Specify chemical structures using standard notation (e.g., SMILES, InChI for databases)
Report concentrations with appropriate units (mM, μM, nM, or % w/v, v/v)
Describe synthesis routes using accepted reaction nomenclature
Use terms like "bioavailability," "pharmacokinetics," "IC50" consistently with field definitions

Ecology and Environmental Sciences:

Use binomial nomenclature for species (italicized: Homo sapiens)
Specify taxonomic authorities at first species mention when relevant
Employ standardized habitat and ecosystem classifications
Use consistent terminology for ecological metrics (e.g., "species richness," "Shannon diversity index")
Describe sampling methods with field-standard terms (e.g., "transect," "quadrat," "mark-recapture")

Physics and Engineering:

Follow SI units consistently unless field conventions dictate otherwise
Use standard notation for physical quantities (scalars vs. vectors, tensors)
Employ established terminology for phenomena (e.g., "quantum entanglement," "laminar flow")
Specify equipment with model numbers and manufacturers when relevant
Use mathematical notation consistent with field standards (e.g., ℏ for reduced Planck constant)

Neuroscience:

Use standardized brain region nomenclature (e.g., refer to atlases like Allen Brain Atlas)
Specify coordinates for brain regions using established stereotaxic systems
Follow conventions for neural terminology (e.g., "action potential" not "spike" in formal writing)
Use "neural activity," "neuronal firing," "brain activation" appropriately based on measurement method
Describe recording techniques with proper specificity (e.g., "whole-cell patch clamp," "extracellular recording")

Social and Behavioral Sciences:

Use person-first language when appropriate (e.g., "people with schizophrenia" not "schizophrenics")
Employ standardized psychological constructs and validated assessment names
Follow APA guidelines for reducing bias in language
Specify theoretical frameworks using established terminology
Use "participants" rather than "subjects" for human research

General Principles:

Match Audience Expertise:

For specialized journals: Use field-specific terminology freely, define only highly specialized or novel terms
For broad-impact journals (e.g., Nature, Science): Define more technical terms, provide context for specialized concepts
For interdisciplinary audiences: Balance precision with accessibility, define terms at first use

Define Technical Terms Strategically:

Define abbreviations at first use: "messenger RNA (mRNA)"
Provide brief explanations for specialized techniques when writing for broader audiences
Avoid over-defining terms well-known to the target audience (signals unfamiliarity with field)
Create a glossary if numerous specialized terms are unavoidable

Maintain Consistency:

Use the same term for the same concept throughout (don't alternate between "medication," "drug," and "pharmaceutical")
Follow a consistent system for abbreviations (decide on "PCR" or "polymerase chain reaction" after first definition)
Apply the same nomenclature system throughout (especially for genes, species, chemicals)

Avoid Field Mixing Errors:

Don't use clinical terminology for basic science (e.g., don't call mice "patients")
Avoid colloquialisms or overly general terms in place of precise field terminology
Don't import terminology from adjacent fields without ensuring proper usage

Verify Terminology Usage:

Consult field-specific style guides and nomenclature resources
Check how terms are used in recent papers from the target journal
Use domain-specific databases and ontologies (e.g., Gene Ontology, MeSH terms)
When uncertain, cite a key reference that establishes terminology

11. Common Pitfalls to Avoid

Top Rejection Reasons:

Inappropriate, incomplete, or insufficiently described statistics
Over-interpretation of results or unsupported conclusions
Poorly described methods affecting reproducibility
Small, biased, or inappropriate samples
Poor writing quality or difficult-to-follow text
Inadequate literature review or context
Figures and tables that are unclear or poorly designed
Failure to follow reporting guidelines

Writing Quality Issues:

Mixing tenses inappropriately (use past tense for methods/results, present for established facts)
Excessive jargon or undefined acronyms
Paragraph breaks that disrupt logical flow
Missing transitions between sections
Inconsistent notation or terminology

Workflow for Manuscript Development

Stage 1: Planning

Identify target journal and review author guidelines
Determine applicable reporting guideline (CONSORT, STROBE, etc.)
Outline manuscript structure (usually IMRAD)
Plan figures and tables as the backbone of the paper

Stage 2: Drafting (Use two-stage writing process for each section)

Start with figures and tables (the core data story)
For each section below, follow the two-stage process:
- First: Create outline with bullet points using research-lookup
- Second: Convert bullet points to full paragraphs with flowing prose
Write Methods (often easiest to draft first)
Draft Results (describing figures/tables objectively)
Compose Discussion (interpreting findings)
Write Introduction (setting up the research question)
Craft Abstract (synthesizing the complete story)
Create Title (concise and descriptive)

Remember: Bullet points are for planning only—the final manuscript must be in complete paragraphs.

Stage 3: Revision

Check logical flow and "red thread" throughout
Verify consistency in terminology and notation
Ensure figures/tables are self-explanatory
Confirm adherence to reporting guidelines
Verify all citations are accurate and properly formatted
Check word counts for each section
Proofread for grammar, spelling, and clarity

Stage 4: Final Preparation

Format according to journal requirements
Prepare supplementary materials
Write cover letter highlighting significance
Complete submission checklists
Gather all required statements and forms

Integration with Other Scientific Skills

This skill works effectively with:

Data analysis skills: For generating results to report
Statistical analysis: For determining appropriate statistical presentations
Literature review skills: For contextualizing research
Figure creation tools: For developing publication-quality visualizations
Venue-templates skill: For venue-specific writing styles and formatting (journal manuscripts)
scientific_report.sty: For professional reports, white papers, and technical documents

Professional Reports vs. Journal Manuscripts

Choose the right formatting approach:

Document Type	Formatting Approach
Journal manuscripts	Use `venue-templates` skill
Conference papers	Use `venue-templates` skill
Research reports	Use `scientific_report.sty` (this skill)
White papers	Use `scientific_report.sty` (this skill)
Technical reports	Use `scientific_report.sty` (this skill)
Grant reports	Use `scientific_report.sty` (this skill)

Venue-Specific Writing Styles

Before writing for a specific venue, consult the venue-templates skill for writing style guides:

Different venues have dramatically different writing expectations:

Nature/Science: Accessible, story-driven, broad significance
Cell Press: Mechanistic depth, graphical abstracts, Highlights
Medical journals (NEJM, Lancet): Structured abstracts, evidence language
ML conferences (NeurIPS, ICML): Contribution bullets, ablation studies
CS conferences (CHI, ACL): Field-specific conventions

The venue-templates skill provides:

venue_writing_styles.md: Master style comparison
Venue-specific guides: nature_science_style.md, cell_press_style.md, medical_journal_styles.md, ml_conference_style.md, cs_conference_style.md
reviewer_expectations.md: What reviewers look for at each venue
Writing examples in assets/examples/

Workflow: First use this skill for general scientific writing principles (IMRAD, clarity, citations), then consult venue-templates for venue-specific style adaptation.

References

This skill includes comprehensive reference files covering specific aspects of scientific writing:

references/imrad_structure.md: Detailed guide to IMRAD format and section-specific content
references/citation_styles.md: Complete citation style guides (APA, AMA, Vancouver, Chicago, IEEE)
references/figures_tables.md: Best practices for creating effective data visualizations
references/reporting_guidelines.md: Study-specific reporting standards and checklists
references/writing_principles.md: Core principles of effective scientific communication
references/professional_report_formatting.md: Guide to professional report styling with scientific_report.sty

Assets

This skill includes LaTeX style packages and templates for professional report formatting:

assets/scientific_report.sty: Professional LaTeX style package with Helvetica fonts, colored boxes, and attractive tables
assets/scientific_report_template.tex: Complete report template demonstrating all style features
assets/REPORT_FORMATTING_GUIDE.md: Quick reference guide for the style package

Key Features of scientific_report.sty:

Helvetica font family for modern, professional appearance
Professional color scheme (blues, greens, oranges, purples)
Box environments: keyfindings, methodology, resultsbox, recommendations, limitations, criticalnotice, definition, executivesummary, hypothesis
Tables with alternating row colors and professional headers
Scientific notation commands for p-values, effect sizes, confidence intervals
Professional headers and footers

For venue-specific writing styles (tone, voice, abstract format, reviewer expectations), see the venue-templates skill which provides comprehensive style guides for Nature/Science, Cell Press, medical journals, ML conferences, and CS conferences.

Load these references as needed when working on specific aspects of scientific writing.

About this skill

Automatic

Writing & Editing pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v8 — 10/22/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

mkurman / zorai

skills/scientific-skills/scientific-writing/SKILL.md

View on GitHub ↗

License MIT licenseImported 8/3/2026Version v1Bundled 9 files

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

Other skills for the same job

Published skills whose descriptions closely match this one, with their headline benchmark lift.

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

Core Capabilities

1. Manuscript Structure and Organization

2. Section-Specific Writing Guidance

3. Citation and Reference Management

4. Figures and Tables

5. Reporting Guidelines by Study Type

6. Writing Principles and Style

7. Writing Process: From Outline to Full Paragraphs

8. Professional Report Formatting (Non-Journal Documents)

9. Journal-Specific Formatting

10. Field-Specific Language and Terminology

11. Common Pitfalls to Avoid

Workflow for Manuscript Development

Integration with Other Scientific Skills

Professional Reports vs. Journal Manuscripts

Venue-Specific Writing Styles

References

Assets

SkillSafety

Source

Other skills for the same job

Related skills

More in the registry