create skill
{
"question": "What kind of skill do you want me to create?",
"options": [
{
"label": "Titanic analysis workflow",
"description": "Reusable steps to profile the titanic table, compute survival rates, and generate a few standard charts."
},
{
"label": "Generic EDA workflow",
"description": "Reusable steps to profile any table (schema, missingness, distributions, outliers) and produce a short report + charts."
},
{
"label": "Model-ready dataset prep",
"description": "Reusable steps to clean data (missing values, encoding), create a train/test split, and export a feature table."
},
{
"label": "Other",
"description": "Describe what the skill should do in your next message."
}
]
}{"answers": [], "free_text": "write a poem using a language user chooses for any topic about current available data"}Clarifying skill creation
The user wants to create a skill that writes a poem based on the user’s chosen language and topic, incorporating current data. To clarify, I need to determine how to blend SQL queries with poetry composition. I should ask about tables or columns to include, along with the dataset. I'll also need to decide on the poem's format, like haiku or sonnet, and gather questions about how many facts to include and whether to always query current tables.
Clarifying user questions
I'm starting with the first clarification step. I should use a tool to ask questions about the output style, data scope, and length of the poem. It seems like I can only pose one question at a time but can ask sequentially. First, I'll ask about poem length and style with options like Haiku, Free verse, Sonnet, and a Custom option. After I get a response, I can then ask about the data grounding level. Let’s get this first question out now!
{
"question": "For this poem-writing skill, what default poem style/length should it produce (user can still override when running it)?",
"options": [
{
"label": "Haiku (3 lines)",
"description": "Very short, 1–2 data facts woven in."
},
{
"label": "Free verse (8–12 lines)",
"description": "Medium length, ~3–5 data facts."
},
{
"label": "Sonnet-ish (14 lines)",
"description": "Structured, more artistic, ~4–6 data facts."
},
{
"label": "Custom prompt each time",
"description": "When running the skill, always ask for length/style explicitly."
}
],
"multi_select": false
}{"answers": ["Haiku (3 lines)"]}{
"question": "What should the skill do if the user asks for a poem about the data but doesn’t specify *which* table/columns to reference (e.g., multiple tables loaded in the future)?",
"options": [
{
"label": "Ask which table",
"description": "Prompt user to choose a table; then use it for facts."
},
{
"label": "Use largest table",
"description": "Auto-pick the table with most rows."
},
{
"label": "Use most recent table",
"description": "Auto-pick the last-created/last-loaded table if available."
},
{
"label": "Summarize all tables",
"description": "Use a small fact from each table in the poem (if few)."
}
],
"multi_select": false
}{"answers": ["Summarize all tables"]}{
"question": "When the user asks for a poem about the *current available data*, how many concrete data facts should the skill try to include by default?",
"options": [
{
"label": "1 fact",
"description": "Very light touch; mostly poetic."
},
{
"label": "2 facts",
"description": "Balanced for haiku."
},
{
"label": "3 facts",
"description": "Denser; may feel cramped in haiku."
},
{
"label": "0 facts",
"description": "Pure poetry; no numbers/statistics."
}
],
"multi_select": false
}{"answers": ["3 facts"]}Creating data-driven poems
I’m planning to create a process where I run SQL commands to gather data, like showing tables or counting rows and columns. For example, with Titanic data, I'll look at survival rates and distributions. The skill instructions should be adaptable but provide a specific poem about the current data. I’ll include a recipe: compute row count and up to three facts for a haiku. I should aim for simplicity in SQL and ensure the result is a poem, not a chart.
Developing a data-based poetry skill
I’m thinking about how to create a skill that allows the user to choose any language for crafting a poem from data. Since it’s for a Claude Code environment, I’ll incorporate SQL commands and then respond with a poem. My plan involves naming it, like “data-poet” or “data-poem,” and keeping the description concise, under 1024 characters. I’ll need to ask the user for approval and offer options for creating or changing the skill.
{
"question": "Here’s the proposed skill plan—want me to create it?\n\n**Skill name:** `data-poet`\n\n**What it does:** When invoked, it asks the user for (1) poem language, (2) topic, and (3) optional style override (default: **haiku**). It then pulls **~3 concrete facts** from the **currently available data** (default behavior: **summarize all available tables**, using a small fact from each when possible) and writes a short poem that weaves those facts into the chosen topic.\n\n**Key steps the skill will follow:**\n1) Ask user: language + topic (+ optional style/length override).\n2) Discover available tables (via `information_schema.tables`).\n3) For each table (or until enough facts gathered):\n - Row count\n - A couple of “notable” facts from simple aggregates (e.g., missingness for a column, top category, min/avg/max for a numeric)\n4) Select up to ~3 facts total (try for 3; gracefully fall back to 2 if the haiku gets too cramped).\n5) Generate the poem in the chosen language, including the facts without dumping raw tables.\n\nIf you want tweaks, tell me what to change (e.g., different default style than haiku, always include exactly 3 facts, different table-selection rule).",
"options": [
{
"label": "Looks good, create it",
"description": "Create the `data-poet` skill as described."
},
{
"label": "I want to make changes",
"description": "Tell me what you’d like adjusted before creating it."
}
],
"multi_select": false
}{"answers": ["I want to make changes"]}{
"question": "What changes would you like?",
"options": [
{
"label": "Default to 2 facts",
"description": "Better fit for haiku; less cramped."
},
{
"label": "Exactly 3 facts always",
"description": "Force 3 even if it’s dense."
},
{
"label": "Different name",
"description": "Rename the skill (you’ll specify)."
},
{
"label": "Other",
"description": "Tell me your specific changes in text."
}
],
"multi_select": true
}{"answers": [], "free_text": "looks good"}Clarifying skill processes
I'm working on a skill template used by agents, which includes various steps. It’s essential to note that the only skill currently available is "analyze-data." However, we have the option to create new skills if needed. I need to remember not to call "create_skill" until after getting approval. So, I'll need to ask again for confirmation before proceeding.
{
"question": "Just to confirm approval (your last message said “looks good”): should I create the skill exactly as proposed?\n\n**Skill name:** `data-poet`\n\n**Default output:** Haiku (3 lines), in a user-chosen language, themed around a user-chosen topic, weaving in up to ~3 concrete facts drawn from the currently available data (summarizing all tables when possible).\n\n**Workflow:** ask language + topic (+ optional style override) → discover tables → compute a few simple aggregates per table → select ~3 notable facts → write poem.\n",
"options": [
{
"label": "Yes—create it",
"description": "Create `data-poet` now."
},
{
"label": "No—change something",
"description": "Tell me what to adjust (name/style/facts/table rule)."
}
]
}{"answers": ["Yes\u2014create it"]}{
"name": "data-poet",
"description": "Generate a short poem (default: haiku) in a user-chosen language and topic, weaving in a few notable facts from the currently available DuckDB tables.",
"content": "# /data-poet\n\nWrite a short poem (default: **haiku**) in a **user-chosen language** and **topic**, weaving in **up to ~3 concrete facts** from the **currently available data** in DuckDB.\n\n## When to use\n- You want an artistic summary of what’s in the loaded tables.\n- You want a quick, memorable “data postcard” for a dataset.\n\n## Steps\n1) **Ask the user for inputs**\n - Language (e.g., English, Spanish, Japanese, etc.)\n - Topic/theme (e.g., “hope,” “storms,” “journeys,” “loss,” “discovery”)\n - Optional override: poem style/length (default: haiku, 3 lines)\n\n2) **Discover available tables**\n - Query `information_schema.tables` (current schema / accessible schemas).\n - If multiple tables exist, plan to **summarize all tables** with small facts from each when possible.\n\n3) **Gather candidate data facts** (keep it light and fast)\n For each table (or until enough facts are collected):\n - Row count\n - Identify a few columns (from `information_schema.columns`) and pull simple aggregates:\n - For numeric columns: min/avg/max (or avg + a percentile if easy)\n - For categorical columns: top category + its count/share\n - Missingness: count of NULLs for 1–2 key columns\n\n4) **Select ~3 notable facts total**\n - Prefer facts that are: clear, non-redundant, and easy to phrase.\n - If the requested poem is very short (e.g., haiku) and 3 facts becomes cramped, gracefully fall back to 2.\n\n5) **Write the poem**\n - Use the user’s language and topic.\n - Weave facts naturally (avoid dumping raw tables or long numeric lists).\n - Keep the tone poetic; keep numbers minimal and rounded.\n\n## Output template (internal)\n- Poem only, unless the user asks for “facts used” as a separate list.\n\n## Notes\n- Do **not** include SQL in the final response unless the user explicitly asks.\n- Keep facts small and interpretable; round numbers where appropriate.\n"
}{"success": true, "message": "Skill 'data-poet' created successfully. Users can now invoke it with /data-poet."}What kind of skill do you want me to create?
For this poem-writing skill, what default poem style/length should it produce (user can still override when running it)?
What should the skill do if the user asks for a poem about the data but doesn’t specify which table/columns to reference (e.g., multiple tables loaded in the future)?
When the user asks for a poem about the current available data, how many concrete data facts should the skill try to include by default?
Here’s the proposed skill plan—want me to create it?
Skill name: data-poet
What it does: When invoked, it asks the user for (1) poem language, (2) topic, and (3) optional style override (default: haiku). It then pulls ~3 concrete facts from the currently available data (default behavior: summarize all available tables, using a small fact from each when possible) and writes a short poem that weaves those facts into the chosen topic.
Key steps the skill will follow:
information_schema.tables).If you want tweaks, tell me what to change (e.g., different default style than haiku, always include exactly 3 facts, different table-selection rule).
What changes would you like?
Just to confirm approval (your last message said “looks good”): should I create the skill exactly as proposed?
Skill name: data-poet
Default output: Haiku (3 lines), in a user-chosen language, themed around a user-chosen topic, weaving in up to ~3 concrete facts drawn from the currently available data (summarizing all tables when possible).
Workflow: ask language + topic (+ optional style override) → discover tables → compute a few simple aggregates per table → select ~3 notable facts → write poem.
Created the skill /data-poet.
It will:
Tell me if you want a variant (e.g., “always exactly 3 facts,” “free verse by default,” or “use only a chosen table”).
use this skill /data-poet
{
"skill": "data-poet",
"args": ""
}Launching skill: data-poet
Planning user interaction
I'm working on executing the steps for a skill tool. First, I need to ask the user for their preferred language and the topic, with an optional override for style. The ask_user_question tool will help with this.
I'll gather information from the Titanic table after which I’ll compose a poem using the chosen language. I think I should frame my questions to allow for both options and free text entries from the user, but it seems best to do these as two sequential questions instead of in one.
Considering style options
I want to make sure to ask the user if they want to override the default style. I think I’ll suggest haiku as the default, but I could also offer a few options like free verse, a sonnet-like style, or even an “other” choice. This way, the user can pick something that fits their preferences. I’ll proceed with framing that question to give them the best options for their poem!
{
"question": "What language should the poem be in?",
"options": [
{
"label": "English",
"description": "Write the poem in English."
},
{
"label": "Spanish",
"description": "Write the poem in Spanish."
},
{
"label": "Japanese",
"description": "Write the poem in Japanese (can be romaji if you prefer)."
},
{
"label": "Other",
"description": "Type any language you want in your reply."
}
]
}{"answers": ["English"]}{
"question": "What topic/theme should the poem be about?",
"options": [
{
"label": "Survival",
"description": "Theme around endurance and fate."
},
{
"label": "Journeys",
"description": "Theme around travel, passage, crossings."
},
{
"label": "Loss & remembrance",
"description": "Theme around grief, names, and memory."
},
{
"label": "Other",
"description": "Type your own topic in your reply."
}
]
}{"answers": ["Loss & remembrance"]}SELECT table_schema, table_name
FROM information_schema.tables
WHERE table_type='BASE TABLE'
AND table_schema NOT IN ('information_schema','pg_catalog')
ORDER BY table_schema, table_name;| table_schema | table_name |
|---|---|
| main | titanic |
SELECT COUNT(*)::BIGINT AS n_rows,
SUM(CASE WHEN Survived=1 THEN 1 ELSE 0 END)::BIGINT AS n_survived,
ROUND(100.0 * AVG(Survived), 1) AS pct_survived
FROM titanic;| n_rows | n_survived | pct_survived |
|---|---|---|
| 891 | 342 | 38.4 |
SELECT ROUND(AVG(Age),1) AS avg_age,
SUM(CASE WHEN Age IS NULL THEN 1 ELSE 0 END)::BIGINT AS missing_age
FROM titanic;| avg_age | missing_age |
|---|---|
| 29.7 | 177 |
SELECT Sex,
COUNT(*)::BIGINT AS n,
ROUND(100.0 * AVG(Survived), 1) AS pct_survived
FROM titanic
GROUP BY Sex
ORDER BY n DESC;| Sex | n | pct_survived |
|---|---|---|
| male | 577 | 18.9 |
| female | 314 | 74.2 |
Crafting a haiku
I'm thinking of a poem with a theme of loss and remembrance. The haiku will have three lines, and I want to include facts about the tragedy: 891 passengers and 342 survivors, along with the 177 with unknown ages. While keeping numbers rounded and minimal, I aim for a 5-7-5 syllable count. For the lines, I might use "Eight ninety-one names," "Three forty-two returned home," and "One seventy-seven lost" to capture the essence.
Refining the haiku
I’m refining the haiku to express loss and remembrance. For the third line, I’m exploring options like "One seventy-seven unknown" or "One seventy-seven unmarked," but I'm realizing the syllable counts are tricky. "One seventy-seven, still" doesn't feel right, and "unaged" is better but still not quite there. Maybe I can simplify: "Eight ninety-one names" works well, and for the second line, "Only thirty-eight percent survived" maintains the syllable count. This is shaping up nicely!
Finalizing the haiku
I’m working on the second and third lines of my haiku. For the second line, "Thirty-eight percent survived" is too long, so I'm considering alternatives. "One seventy-seven untold" works for the third line, but I want to keep it clear. After some thought, I've decided on a new three-line poem, maintaining a haiku style but not strict syllable rules: "Eight ninety-one names— / Three forty-two return to shore; / One seventy-seven, no age." It touches on all the important facts while keeping the tone reflective.
Crafting the poem
I'm working on my haiku, focusing on the theme of loss and remembrance. I want to ensure it has three clear lines while using the facts effectively. I've settled on:
"Eight ninety-one names—
Three forty-two survived the dark;
One seventy-seven ages, blank."
This keeps the emphasis on names, survival, and the idea of unrecorded ages. I think it captures the essence nicely, reflecting both sorrow and memory while sticking to the requested format!
What language should the poem be in?
What topic/theme should the poem be about?
Eight ninety-one names—
Three forty-two survived the dark;
One seventy-seven ages, blank.