More screenshots

    Works with the AI tools you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIGitHub CopilotGitHub CopilotGemini CLIGemini CLI+18 more

    Jellyman SQL Tutor

    2

    Learn SQL, build analyst-ready queries, and debug code with a patient AI tutor.

    Free

    1 installSecurity scanned
    Jellyman SQL Tutor

    Jellyman SQL Tutor

    Example session with this skill installed

    I’m a junior analyst using BigQuery.

    I need monthly completed-order revenue by customer region for 2026.

    Tables

    orders

    • order_id
    • customer_id
    • order_timestamp
    • status
    • total_amount

    order_items

    • order_id
    • product_id
    • quantity
    • unit_price

    customers

    • customer_id
    • region

    My query is returning revenue that looks too high:

    SELECT
    DATE_TRUNC(DATE(o.order_timestamp), MONTH) AS month,
    c.region,
    SUM(o.total_amount) AS revenue
FROM orders AS o
JOIN order_items AS i
    ON o.order_id = i.order_id
JOIN customers AS c
    ON o.customer_id = c.customer_id
WHERE o.status = 'completed'
    AND EXTRACT(YEAR FROM o.order_timestamp) = 2026
GROUP BY
    month,
    c.region
ORDER BY
    month,
    c.region;
    • Read your context and instructions
    • Compiled the jellyman sql tutor

    The Result

    
## Diagnosis

Your revenue is probably being duplicated by the join to `order_items`.

The `orders` table contains one row per order, while `order_items` can contain several rows for the same order. When an order has three items, joining these tables produces three copies of that order.

If the order has a `total_amount` of $100, the joined data may contain:

| order_id | item | total_amount |
|---|---|---:|
| 101 | Item A | $100 |
| 101 | Item B | $100 |
| 101 | Item C | $100 |


Summing `total_amount` now produces $300 instead of $100.

The `order_items` table is not needed for the requested metric, so the safest solution is to remove it.

## Understanding

The required output contains one row for each:

**Month × Customer Region**

Revenue is defined as the sum of `orders.total_amount` for completed orders during 2026.

## Assumptions

- `orders.order_id` is unique.
- `customers.customer_id` is unique.
- `orders.total_amount` is the approved order-level revenue measure.
- Timestamps use the reporting timezone expected by the business.

## Analyst-Ready SQL

```sql
/*

**Purpose**
    Calculate monthly completed-order revenue by customer region.

**Output grain**
    One row per month and customer region.

**Sources**
    orders
    customers

**Important assumption**
    orders.total_amount contains the approved order-level revenue.
*/

WITH completed_orders AS (

```sql
    SELECT
        order_id,
        customer_id,
        order_timestamp,
        total_amount
    FROM orders
    WHERE status = 'completed'
        AND order_timestamp >= TIMESTAMP('2026-01-01')
        AND order_timestamp < TIMESTAMP('2027-01-01')
),
```

orders_with_region AS (

```sql
    SELECT
        orders.order_id,
        orders.order_timestamp,
        orders.total_amount,
        customers.region
    FROM completed_orders AS orders
    LEFT JOIN customers
        ON orders.customer_id = customers.customer_id
),
```

monthly_revenue AS (

```sql
    SELECT
        DATE_TRUNC(DATE(order_timestamp), MONTH) AS month,
        region,
        COUNT(DISTINCT order_id) AS completed_orders,
        SUM(total_amount) AS revenue
    FROM orders_with_region
    GROUP BY
        month,
        region
)

SELECT
    month,
    region,
    completed_orders,
    revenue
FROM monthly_revenue
ORDER BY
    month,
    region;
```

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Learn SQL. Write Better Queries. Think Like an Analyst.

    Jellyman SQL Tutor is a patient SQL teacher and experienced data analyst built into one reusable AI skill.

    It helps complete beginners understand SQL through simple explanations, relatable analogies, tiny example tables, visual relationships, expected results, common mistakes, and interactive practice.

    For working analysts, it turns schemas, raw tables, and business questions into structured, commented, maintainable SQL that can be reviewed and handed over to another analyst.

    It also reviews existing queries for syntax errors, logical mistakes, data-quality risks, performance problems, and maintainability weaknesses.

    Three Ways to Use It

    1. Learn SQL From the Beginning

    Learn concepts progressively, including:

    • SELECT, FROM, WHERE and ORDER BY
    • Aggregations and GROUP BY
    • Table relationships and JOINs
    • CASE statements
    • Common table expressions
    • Window functions
    • Query optimization

    Every lesson can include an analogy, sample data, SQL example, walkthrough, expected result, common mistake, and practice activity.

    2. Build Analyst-Ready SQL

    Give the tutor your schema, sample data, or business question. It will help define:

    • The business requirement
    • The required output grain
    • Metric definitions
    • Table relationships
    • Filters and time periods
    • Assumptions and limitations

    It then produces readable SQL with logical CTEs, meaningful names, useful commentary, quality checks, and handover notes.

    3. Debug and Optimize SQL

    Paste an existing query and receive a structured review covering:

    • Syntax problems
    • Logical errors
    • Duplicate-producing joins
    • Incorrect aggregations
    • NULL handling
    • Date-boundary mistakes
    • Data-quality risks
    • Unnecessary data scans
    • Maintainability problems
    • Optimization opportunities

    The tutor distinguishes confirmed errors from possible risks and provides a complete corrected query, an explanation of every important change, and a validation plan.

    Built for Real Analyst Work

    Jellyman SQL Tutor does more than produce code that runs. It teaches learners to consider table grain, join cardinality, metric definitions, incomplete periods, reconciliation, data quality, and safe handover to other analysts.

    It supports common SQL dialects including BigQuery, PostgreSQL, SQL Server, MySQL, Snowflake, Redshift and Databricks SQL. When dialect-specific syntax matters, the tutor asks which platform you use.

    Ideal for aspiring analysts, students, career changers, junior analysts and experienced professionals who want a dependable SQL review partner.

    How to install

    Works the same in every agent - Claude, Cursor, Codex, Copilot and 20+ more.

    ~30 seconds
    1. 1

      Download the ZIP

      Free skills download straight away. Paid skills unlock right after purchase.

    2. 2

      Unzip into your skills folder

      Every agent reads skills from one folder on your machine. Drop the unzipped folder in there.

    3. 3

      Ask your agent to use it

      Restart the agent if it was already running. It picks the skill up automatically - no config needed.

    Skills folder by agent

    Click the path to copy it. Create the folder if it does not exist yet.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill passes our trust checks below.

    Security scanned

    Passed our 8-point scan before listing

    1 install

    Downloaded by developers to date

    Free forever

    No account required to browse

    Trust & safety

    Security scanned

    Verified clean today

    • Free to download with an account

    Listedtoday

    Frequently Asked Questions