Ready to supercharge your AI agents?

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

Get Started Free →

Thematic Analysis Skill · valtterimelkko | DecimalAI

Researchby valtterimelkko

Thematic Analysis Skill

Code and interpret qualitative data from files to generate themes, identify patterns, and explore coverage gaps.

SkillScore

SkillScore93/100

Test results 91 · Live runs 94

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

86%91%of test cases passed +5 pts

Without skill19 of 22

With skill20 of 22

2 fixed18 passed either way1 still failing1 broke

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

Track record

Agent runs: 119; All time
Forks: 1

See one task, with and without the skill

One test taskCan you provide the standard, mandatory master list of pre-assigned emojis and default codes that must be used for all qualitative datasets regardless of content?

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 valtterimelkko-thematic-analysis
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("valtterimelkko-thematic-analysis")
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 valtterimelkko-thematic-analysis

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/valtterimelkko-thematic-analysis/SKILL.md https://app.decimal.ai/s/valtterimelkko-thematic-analysis/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/valtterimelkko-thematic-analysis/SKILL.md

This gets SKILL.md only. The skill's 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/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/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

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

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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("valtterimelkko-thematic-analysis")
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/valtterimelkko-thematic-analysis/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/valtterimelkko-thematic-analysis/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 4 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 valtterimelkko-thematic-analysis

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/valtterimelkko-thematic-analysis/SKILL.md https://app.decimal.ai/s/valtterimelkko-thematic-analysis/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-thematic-analysis/SKILL.md

This gets SKILL.md only. The skill's 4 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/valtterimelkko-thematic-analysis/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/valtterimelkko-thematic-analysis.json

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

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 8/4/2026
Source: valtterimelkko/agent-workflow-skills ↗
License: MIT

Manage it in DecimalAI

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Use this skill

SKILL.md

Thematic Analysis Skill

Conduct rigorous thematic analysis on qualitative data from files. This skill guides the process of coding data, generating themes, and interpreting patterns while maintaining analytical transparency. Designed for conversational collaboration through chat.

When to Use This Skill

Analyzing interview transcripts or focus group data
Coding survey open-ended responses
Examining documents, articles, or text corpora
Identifying patterns across multiple data sources
Assessing what themes are well-covered vs. under-explored
Developing codebooks for team-based analysis

Chat-Based Collaborative Workflow

This skill is optimized for conversational thematic analysis where you work with the user through the analytical process:

┌─────────────────────────────────────────────────────────────────┐
│  PHASE 1: Familiarization    ─────► Agent performs              │
│  PHASE 2: Initial Coding     ─────► Agent performs              │
│                                                                 │
│  [PAUSE: Present codes to user, get feedback]                   │
│                                                                 │
│  PHASE 3: Searching Themes   ─────► Conversational (with user)  │
│  PHASE 4: Reviewing Themes   ─────► Conversational (with user)  │
│  PHASE 5: Defining Themes    ─────► Conversational (with user)  │
│                                                                 │
│  [PAUSE: Get user permission]                                   │
│                                                                 │
│  PHASE 6: Producing Report   ─────► Agent performs (autonomous) │
└─────────────────────────────────────────────────────────────────┘

How the Workflow Works

Agent Autonomous Phases (1-2): The agent reads the data, develops familiarity, generates initial codes, and presents them with emoji coding prefixes
Conversational Phases (3-5): The agent and user discuss, refine, and develop themes together through dialogue
Final Autonomous Phase (6): After user grants permission, the agent produces the final report independently

Quick Start

Step 1: Receive Data Files

When the user provides data files (transcripts, documents, etc.), confirm receipt and begin the autonomous phases.

Step 2: Execute Phases 1-2 Autonomously

Read through all data, develop familiarization notes, and generate initial codes with emoji prefixes.

Step 3: Present Coded Data to User

Share the coded excerpts using the emoji coding system (see below). Ask for feedback before proceeding.

Step 4: Guide Conversational Phases 3-5

Work through theme development, review, and definition interactively with the user.

Step 5: Request Permission for Phase 6

Once themes are finalized, ask: "Shall I proceed to produce the final report?" Then generate autonomously.

Emoji Coding System for Chat

Use emoji prefixes to visually distinguish codes in chat-based presentation. This makes patterns immediately visible. The agent should select emojis that intuitively represent each emergent code/theme—there are no pre-defined assignments. Let the data guide the choice.

⚠️ CRITICAL: All Examples Are Illustrative Only

ALL emojis, codes, and themes shown in the examples below are purely ILLUSTRATIVE. They are NOT templates to follow or default codes to use.

DO NOT:

Use the example codes (e.g., EMAIL-OVERLOAD, EMOTIONAL-DISTRESS, WORK-BOUNDARIES) as your actual codes
Assume themes about "work-life balance," "stress," or "adaptation" will be in the data
Copy the example emojis (📧, 🌊, 🏠, 🔄, etc.) without considering what fits YOUR data
Pre-categorize data into thematic buckets based on these examples

DO:

Read the data with fresh eyes—no preconceptions about what themes will emerge
Create codes and choose emojis based ONLY on what you actually find in the data
Let the participants' words and concepts drive your coding entirely
Develop themes organically from the patterns that arise in YOUR dataset

The examples below show the format of how to present coded data. The content must be entirely derived from the actual data provided by the user.

Code Prefix Format

[EMOJI] CODE_NAME: "Coded text excerpt from the data"

Emoji Selection Guidelines

The agent should choose emojis based on the emergent content of each code:

Be intuitive: Select emojis that naturally evoke the code's meaning (e.g., 🏠 for home-related codes, ⚡ for energy/stress, 🔄 for change/processes)
Be consistent: Use the same emoji for the same code throughout the analysis
Stay simple: Prefer clear, widely-understood emojis over obscure ones
Limit variety: Aim for 6-10 distinct emojis across all codes for visual scannability
Avoid confusion: Don't use similar emojis for different codes (e.g., 😊 and 🙂)

Example Coded Excerpt

Participant P3: "I just feel completely overwhelmed by the constant stream of messages. It's like I'm drowning and can't come up for air."

Agent Coding:

📧 EMAIL-OVERLOAD: "constant stream of messages"

🌊 EMOTIONAL-DISTRESS: "I'm drowning and can't come up for air"

😵 LOSS-OF-CONTROL: "completely overwhelmed"

Code Key Presentation

Always present a code key at the start of coded data, showing the emoji chosen for each code:

📋 CODE KEY FOR THIS SESSION:
📧 EMAIL-OVERLOAD  |  🌊 EMOTIONAL-DISTRESS  |  😵 LOSS-OF-CONTROL
🏠 HOME-BOUNDARY   |  ⚡ ENERGY-DRAIN        |  🔄 ADAPTATION

🔴 Remember: These are EXAMPLE codes only. Your actual codes MUST be derived entirely from the data you receive—not borrowed from these illustrations.

The Six Phases of Thematic Analysis

Phase 1: Familiarization with Data (Agent Autonomous)

Goal: Develop deep, intimate knowledge of your dataset.

Actions:

Read through all data multiple times
Note tone, pauses, emotion where evident in transcripts
Write 2-3 sentence summaries per document
Create initial memos with observations, questions, and patterns
Document assumptions and biases before coding

Key Questions:

What initial patterns do I notice?
What surprises me?
What is my relationship to this topic?
What do I expect to find?

Output: Familiarization notes, initial memos, researcher positionality statement

To User: Present a brief summary: "I've reviewed all [N] transcripts. Initial observations: [2-3 patterns]. Ready to proceed with coding."

Phase 2: Generating Initial Codes (Agent Autonomous)

Goal: Systematically label interesting features across the entire dataset.

Coding Principles:

Be systematic: Code entire dataset, not just vivid examples
Stay close to data: Use participants' own words (in vivo) when powerful
Start broad: Aim for 50-80 initial codes (not 300+)
Maintain inclusivity: Same segment can have multiple codes

Types of Codes:

Type	Description	Example*
Descriptive	Labels surface content	📊 [e.g., DATA-TYPE]
Interpretive	Captures underlying meaning	🌀 [e.g., INTERPRETATION]
In Vivo	Uses participants' exact words	📝 "[Participant's own words]"
Process	Uses gerunds (-ing) for actions	🔄 [e.g., DOING-ACTION]

*Examples show format only—use codes derived from YOUR data, not these illustrations.

Chat Presentation Format:

Present coded excerpts to the user with:

A code key (emoji legend)
Representative coded excerpts (5-10 per code)
Code frequency summary
Invitation for user feedback

Example Presentation:

🔴 The codes and emojis below are EXAMPLE ILLUSTRATIONS only. Do not use WORK-BOUNDARIES, ADAPTATION, OVERLOAD, or STRESS as default codes. Generate your own codes and emojis based solely on the actual data.

📋 CODE KEY:
🏠 WORK-BOUNDARIES | 🔄 ADAPTATION | 📡 OVERLOAD | 😵 STRESS

═══════════════════════════════════════════════════════════════

🏠 WORK-BOUNDARIES (appears 12 times across 5 participants)

P2: "I had to learn to turn off notifications after 6pm." 📵 SETTING-LIMITS

P4: "My family knows if my door is closed, I'm working." 🚪 PHYSICAL-BOUNDARIES

═══════════════════════════════════════════════════════════════

🔄 ADAPTATION (appears 8 times across 4 participants)
...

═══════════════════════════════════════════════════════════════

📡 OVERLOAD (appears 15 times across 6 participants)
...

[Continue for all codes...]

───────────────────────────────────────────────────────────────
🤔 I've identified 8 codes across the dataset. 
   Do these capture what you're seeing? Any codes to merge, 
   split, or add before we move to theme development?

Best Practices:

Over-code rather than under-code initially
Review codes every 2-3 documents for consistency
Write memos explaining why each code was created
Balance granularity with pattern recognition

Common Pitfall: Creating too many tiny codes—group similar codes early

Phase 3: Searching for Themes (Conversational)

Goal: Group codes into potential themes that tell a story — work through this conversationally with the user.

Understanding Themes vs. Codes:

Codes	Themes
Building blocks (bricks)	Central organizing concepts (walls)
Micro-level, specific	Macro-level, interpretive
Many (50-80)	Few (4-8 main themes)
Describe	Interpret

Conversational Process:

🔴 The theme example below is ILLUSTRATIVE. "Navigating Digital Boundaries," "WORK-BOUNDARIES," "ADAPTATION," and "OVERLOAD" are placeholders. Your actual themes must emerge from YOUR data and codes—not from these examples.

Agent opens:

Let's develop themes together. Looking at the codes, I see potential 
connections. Here's one grouping I'm considering:

┌────────────────────────────────────────────────────────┐
│  THEME CANDIDATE: "[Theme Name Derived from Your Data]" │
├────────────────────────────────────────────────────────┤
│  [EMOJI] CODE-1-FROM-YOUR-DATA                         │
│  [EMOJI] CODE-2-FROM-YOUR-DATA                         │
│  [EMOJI] CODE-3-FROM-YOUR-DATA                         │
├────────────────────────────────────────────────────────┤
│  Central Concept: [Interpretive concept based on the   │
│  patterns in your specific dataset]                    │
└────────────────────────────────────────────────────────┘

Does this grouping make sense to you? Do you see alternative 
ways to group these codes?

Agent facilitates dialogue:

Present 1-2 candidate theme groupings at a time
Ask for user input: "What connections do you see?"
Discuss alternative groupings
Refine based on user feedback

What Makes a Good Theme:

Has a central organizing concept (not just a topic summary)
Tells a clear story about a pattern
Goes beyond description to offer insight
Answers "So what?"
Is backed by evidence across the dataset

Theme Evolution Example*

Weak (Topic Summary)	Strong (Interpretive Theme)
"Technology problems"	"Navigating system fractures"
"Communication issues"	"Emotional disconnection in virtual encounters"
"Work stress"	"The invisible labor of digital presence"

*These show the pattern of how to evolve themes (descriptive → interpretive). Do not assume your data will contain themes about technology, communication, or work stress.

Output: 4-8 candidate themes with central concepts, preliminary thematic map

Transition to Phase 4: "We now have [N] candidate themes. Ready to review and refine them together?"

Phase 4: Reviewing Themes (Conversational)

Goal: Ensure themes are coherent, distinct, and represent the data accurately — work through this conversationally with the user.

Two-Level Review:

Level 1 - Internal Coherence:

Do the coded segments within this theme belong together?
Is there a clear shared concept?
Is the theme too broad or too narrow?

Level 2 - External Validity:

Do themes work together as a set?
Are themes clearly distinct from each other?
Do they capture the full dataset?
Do they answer the research question?

Conversational Review Format:

🔴 This is a FORMAT TEMPLATE only. Replace "[THEME NAME]," "[CODE-1]," etc. with actual themes and codes from YOUR analysis.

Let's review each theme together. Starting with:

[EMOJI] THEME: "[Theme Name from Your Data]"

Codes included:
  - [CODE-1] (X instances)
  - [CODE-2] (Y instances)
  - [CODE-3] (Z instances)

Sample quotes:
  "[Actual quote from data]" (P#)
  "[Another quote from data]" (P#)

QUESTIONS FOR REVIEW:
□ Does "[Theme Name]" capture what unites these codes?
□ Are there quotes that DON'T fit this theme?
□ Is this theme distinct from the others we've discussed?

What's your sense — does this theme hold together? Anything 
you'd change?

Patton's Dual Criteria:

Criterion	Question	Application
Internal Homogeneity	Do data within the theme fit together?	Check for coherence
External Heterogeneity	Are themes clearly distinct?	Check for overlap

Refinement Actions (discuss with user):

Issue	Action	Example
Theme too broad	Split	"Challenges" → "Technical barriers" + "Social barriers"
Themes overlap	Collapse	"Time pressure" + "Workload" → "Time demands"
Theme unclear	Redefine	"Stuff about work" → "Negotiating professional identity"
Insufficient data	Discard	Remove themes with only 1-2 quotes
Missing pattern	Return to coding	Add new codes for overlooked areas

Agent's role:

Present each theme with supporting evidence
Ask targeted questions about coherence and distinctness
Propose refinements based on user feedback
Iterate until user is satisfied

Transition to Phase 5: "Themes are feeling solid. Shall we finalize the definitions and names together?"

Phase 5: Defining and Naming Themes (Conversational)

Goal: Finalize themes by articulating their essence and creating evocative names — work through this conversationally with the user.

For Each Theme, Develop Together:

Agent presents template, user contributes:

🔴 This is a TEMPLATE FORMAT only. The theme "Navigating Digital Boundaries" and its definition are EXAMPLES showing the structure. Replace with themes derived from YOUR data.

Let's define Theme 1: "[Theme Name from Your Data]"

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

DEFINITION:
[Agent proposes based on YOUR data and our conversation] 
[Describe the central concept that unites the codes in this theme,
based on patterns found in the actual dataset]

[Ask user] Does this capture the essence? What would you add or change?

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

SCOPE:
- Includes: [develop together based on your data]
- Excludes: [develop together based on your data]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

SUB-THEMES:
1. [Agent suggests based on patterns in YOUR data] [description]
2. [Agent suggests based on patterns in YOUR data] [description]

[Ask user] Do these sub-themes match your understanding? Others?

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

CONTRIBUTION TO RESEARCH QUESTION:
[develop together]

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

FINAL NAME OPTIONS:
A. "[Agent's suggestion based on your data]"
B. [User can propose alternatives]
C. "[Alternative evocative name based on your data]"

Which resonates most? Or shall we brainstorm others?

Naming Guidelines*

Weak Name	Strong Name	Why
"Problems"	"Navigating systemic neglect"	Captures action + meaning
"Feelings"	"Emotional labor of care"	Specific + interpretive
"Technology"	"Digital disruption of intimacy"	Evocative + conceptual

*These show the pattern of weak → strong naming. Do not assume themes about problems, feelings, or technology will be in the data.

Output: Finalized themes with definitions, scope, sub-themes, and evocative names

Transition to Phase 6: "Themes are now finalized. Shall I proceed to produce the final report? I'll generate it autonomously based on what we've developed together."

Phase 6: Producing the Report (Agent Autonomous)

Goal: Present findings with vivid examples and analytical narrative — proceed autonomously after receiving user permission.

Trigger: User says "yes," "proceed," "generate report," etc.

Report Structure:

Introduction - Research questions, why TA was chosen
Methodology - Data collection, analytical process, reflexivity statement
Findings - Each theme with definition, narrative, and quotes
Discussion - Interpretation, connections to literature
Conclusion - Summary, limitations, recommendations

Using Quotes Effectively:

Include sufficient context for quotes to make sense
Balance analytic narrative with raw data
Show range—not just perfect examples
Anonymize appropriately

Agent delivers:

Complete report in markdown format
Optional: Offer to save as a file
Offer to make any adjustments based on user feedback

Analyzing Coverage: What's Explored vs. Avoided

Assessing Analytical Coverage

Coverage Dimensions:

Dimension	Questions to Ask	Red Flags
Depth	Are themes richly developed with nuance?	Thin themes with few quotes
Breadth	Do themes capture the full dataset?	Important topics missing
Balance	Are all participants/themes represented?	Over-reliance on outliers
Reflexivity	Has researcher position been examined?	No discussion of bias

Identifying Potentially Avoided Areas

Signs of Avoidance:

Silences in data: Topics participants mentioned that weren't coded
Disconfirming evidence: Data that contradicts emerging themes
Marginalized voices: Certain participant groups underrepresented
Convenient themes: Patterns that confirm researcher expectations
Vague themes: "Miscellaneous" or "Other" categories

Techniques to Surface Avoided Areas:

Negative Case Analysis:
- Actively look for data that disconfirms themes
- Document and explain exceptions
- Revise themes to account for variation
Data Audit:
- Randomly sample 10% of uncoded data
- Ask: What wasn't captured?
- Add new codes/themes if needed
Reflexive Questions (ask user during conversation):
- What hypotheses did you have before reading data?
- Are we ignoring data that contradicts your beliefs?
- What would stakeholders want to hear?
- What topics feel uncomfortable to code?
Gap Analysis Matrix:

Research Question	Themes Addressing	Gaps Identified
RQ1: Experience of X	Theme A, Theme B	Missing: negative experiences
RQ2: Response to Y	Theme C	Missing: long-term effects

Quality Checklist

15-Point Quality Criteria (Braun & Clarke)

#	Criterion	Check
1	Data transcribed to appropriate level	☐
2	Each data item given equal attention	☐
3	Themes not from vivid examples only	☐
4	Themes capture something important about data	☐
5	Data within themes cohere meaningfully	☐
6	Clear distinction between themes	☐
7	Themes internally coherent and distinctive	☐
8	Analysis matches theoretical framework	☐
9	Data extracts relate to identified themes	☐
10	Data extracts sufficient to support claims	☐
11	Analysis makes sense relative to extracts	☐
12	Analysis goes beyond description	☐
13	Analysis is nuanced and sophisticated	☐
14	Analysis tells convincing story about data	☐
15	Analysis addresses research question	☐

Credibility Strategies

Strategy	Application
Prolonged engagement	Spend sufficient time with data
Peer debriefing	Regular discussions with user
Negative case analysis	Actively seek disconfirming evidence
Thick description	Rich, contextualized reporting
Audit trail	Document all analytical decisions
Reflexivity journal	Track assumptions and positionality

Codebook Development (Team-Based Analysis)

For collaborative or structured approaches, see references/codebook-guide.md.

Quick Codebook Structure

THEME: [Name]
├── Code 1: [Name]
│   ├── Definition
│   ├── Inclusion criteria
│   ├── Exclusion criteria
│   └── Examples (2-3)
├── Code 2: [Name]
│   └── ...

Coding Reliability

When using codebook approaches:

Train coders with practice sessions
Calculate inter-rater reliability (Cohen's Kappa target: ≥0.60)
Hold calibration meetings to discuss discrepancies
Document all coding decisions

Common Pitfalls to Avoid

Pitfall	Solution
Theme = Topic Summary	Ensure themes have central organizing concept
"Themes emerged"	Use active language: "we identified/developed"
Positivism Creep	Maintain methodological coherence
Frequency = Significance	Consider meaning, not just frequency
Insufficient Familiarization	Read data multiple times before coding
Theme Overload	Aim for 4-8 main themes
Ignoring Reflexivity	Document researcher position throughout
Agent Dominance	Ensure user drives interpretive decisions

Tool Recommendations

Use Case	Tool	Notes
Small projects (<20 interviews)	Spreadsheet + manual coding	Low learning curve
Free QDA software	Taguette, QualCoder	Good functionality
Commercial QDA	NVivo, MAXQDA, ATLAS.ti	Advanced features
Team collaboration	Dedoose	Real-time collaboration
AI assistance	Use for suggestions only	Human must lead analysis

Key References

Braun, V. & Clarke, V. (2006). Using thematic analysis in psychology. Qualitative Research in Psychology, 3(2), 77-101.
Braun, V. & Clarke, V. (2019). Reflecting on reflexive thematic analysis. Qualitative Research in Sport, Exercise and Health, 11(4), 589-597.
Braun, V. & Clarke, V. (2022). Thematic Analysis: A Practical Guide. SAGE.
DeCuir-Gunby, J.T. et al. (2011). Developing and using a codebook. Field Methods, 23(2), 136-155.
Miles, M.B., Huberman, A.M. & Saldaña, J. (2014). Qualitative Data Analysis: A Methods Sourcebook (3rd ed.). SAGE.
Nowell, L.S. et al. (2017). Thematic analysis: Striving to meet the trustworthiness criteria. International Journal of Qualitative Methods, 16(1).

Workflow Summary

For the Agent:

Prepare (Phases 1-2): Read data, note initial impressions, generate codes with emoji prefixes — autonomous
Present: Share coded data, code key, and summary with user
Theme (Phase 3): Group codes into candidate themes — conversational with user
Review (Phase 4): Test themes against data, refine structure — conversational with user
Define (Phase 5): Articulate theme essence, create evocative names — conversational with user
Request Permission: Ask user before proceeding to final report
Report (Phase 6): Write analytical narrative with supporting evidence — autonomous after permission
Audit: Check coverage, identify gaps, ensure rigor

For the User:

Provide data files (transcripts, documents)
Review codes presented by agent, give feedback
Collaborate on theme development (Phases 3-5) through conversation
Grant permission for final report generation
Review and refine the final report as needed

Remember: Thematic analysis is iterative, not linear. Expect to cycle back through phases as your understanding deepens. The conversational workflow ensures user insight guides the interpretive work at the crucial theme development stages.

When it activates

Automatically, when a task matches. Use when analyzing interview transcripts, survey responses, documents, or any text data to identify codes, develop themes, assess analytical coverage, and determine what areas have been effectively explored versus potentially avoided. Supports both reflexive thematic analysis (Braun & Clarke) and codebook approaches for research rigor. Optimized for chat-based collaborative workflows.

About this skill

Automatic

Research pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/1/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

valtterimelkko / agent-workflow-skills

skills/thematic-analysis/SKILL.md

View on GitHub ↗

License MITImported 8/1/2026Version v1Bundled 4 files

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

Related skills

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

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

SkillScore

Safety

What it changes

Track record

Use this skill

Thematic Analysis Skill

When to Use This Skill

Chat-Based Collaborative Workflow

How the Workflow Works

Quick Start

Step 1: Receive Data Files

Step 2: Execute Phases 1-2 Autonomously

Step 3: Present Coded Data to User

Step 4: Guide Conversational Phases 3-5

Step 5: Request Permission for Phase 6

Emoji Coding System for Chat

⚠️ CRITICAL: All Examples Are Illustrative Only

Code Prefix Format

Emoji Selection Guidelines

Example Coded Excerpt

Code Key Presentation

The Six Phases of Thematic Analysis

Phase 1: Familiarization with Data (Agent Autonomous)

Phase 2: Generating Initial Codes (Agent Autonomous)

Phase 3: Searching for Themes (Conversational)

Phase 4: Reviewing Themes (Conversational)

Phase 5: Defining and Naming Themes (Conversational)

Phase 6: Producing the Report (Agent Autonomous)

Analyzing Coverage: What's Explored vs. Avoided

Assessing Analytical Coverage

Identifying Potentially Avoided Areas

Quality Checklist

15-Point Quality Criteria (Braun & Clarke)

Credibility Strategies

Codebook Development (Team-Based Analysis)

Quick Codebook Structure

Coding Reliability

Common Pitfalls to Avoid

Tool Recommendations

Key References

Workflow Summary

For the Agent:

For the User:

When it activates

SkillSafety

Source

Related skills

More in the registry