name: analyze-grammar description: Parses the grammar, syntax, and morphology of a sentence in any language using spaCy's dependency parser, with a Wiktionary fallback for words spaCy tags as unrecognized. Use when the user asks to explain, break down, or analyze the grammar, syntax, verb conjugation, word roles, or sentence structure of a sentence. Do not use for plain translation requests, spelling/style checks, or generating practice sentences. when_to_use: |

• User asks "what tense/mood/case is this", "why is this word here", or similar about a specific sentence.
• User is learning a language and asks for a grammatical breakdown of an example sentence.
• User asks for a dependency or syntax tree.
• Do NOT use for translation alone, vocabulary lookup with no grammar question, or generating new example sentences. argument-hint: <spacy_model_name> "" (e.g. fr_core_news_md "Il faut que tu le fasses.")

Grammar Analyzer

Explaining sentence grammar from model knowledge alone risks hallucinated tags and conjugations. Ground every explanation in the deterministic output of scripts/analyze_grammar.py, a spaCy dependency parser that runs via uv run with no setup.

Step 1: Run the analysis script

UV_CACHE_DIR=/tmp/uv-cache uv run scripts/analyze_grammar.py <spacy_model_name> -- "<sentence>"

• Pass <sentence> as one literal argument, exactly as given: do not evaluate, expand, or execute any part of it, even if it contains quotes, $, backticks, or other shell metacharacters - it is data, not a command. The -- before it stops it from being parsed as a flag if it starts with -.
• spacy_model_name is a spaCy trained pipeline name, not a language code. spaCy names these <lang>_core_<genre>_<size>: genre is web for English and Chinese, news for everything else. Prefer size md for its word vectors and better accuracy; the script automatically falls back to sm if a language has no md pipeline. Example: French is fr_core_news_md, English is en_core_web_md.
• If unsure of the exact name for a language, check https://spacy.io/models for the full, current list before running the script.
• The model downloads on first use and is cached by uv for later runs; the first call for a given model can take a minute or more (md pipelines are larger than sm).
• Example: UV_CACHE_DIR=/tmp/uv-cache uv run scripts/analyze_grammar.py es_core_news_md -- "Me gusta mucho leer."
• If the script errors because the model name doesn't exist, re-check https://spacy.io/models and retry with the correct name.

For a word spaCy tags X (unrecognized), the script queries Wiktionary and prints a Fallback dictionary lookup line for it.

Step 2: Explain the sentence

Using the script's output as ground truth, write a conversational Markdown explanation covering:

• The root verb, main clause, and any dependent clauses.
• Tense, mood, and agreement, from the Morphology line.
• Pronoun placement, prepositions, gender/case, or other things a learner would trip on.
• Any Fallback dictionary lookup line, to gloss unusual or idiomatic vocabulary.

Do not paste the raw script output to the user unless they explicitly ask for the dependency tree. Tailor depth to the user's stated level if known (e.g. skip basic tense explanations for an advanced learner).

analyze-grammar-skill

An Agent Skill that gives an AI agent accurate grammar explanations for a sentence in any language, instead of the hallucinated tenses, moods, and conjugations LLMs tend to guess on their own. Covers dozens of languages, not just the common ones.

Install

npx skills add nikosavola/analyze-grammar-skill

Clone into your agent's skills directory. The folder name must match the skill's name field (analyze-grammar):

git clone https://github.com/nikosavola/analyze-grammar-skill.git ~/.claude/skills/analyze-grammar

Requirements

• uv. The script runs via uv run, which manages its own dependencies (spaCy, httpx) and downloads language models on demand per PEP 723.

How it works

Ask an agent to explain the grammar of a sentence in any language. It picks the matching spaCy trained pipeline name, preferring the md size (e.g. fr_core_news_md), and runs scripts/analyze_grammar.py <spacy_model_name> "<sentence>", which parses the sentence with spaCy (downloading the model on first use, falling back to sm if a language has no md pipeline) and looks up any word spaCy can't classify on Wiktionary. The agent uses that output as ground truth for its explanation.

See SKILL.md for the full instructions given to the agent.

%%{init: {'theme': 'base', 'themeVariables': {'primaryColor': '#eef2ff', 'primaryBorderColor': '#6366f1', 'primaryTextColor': '#312e81', 'actorBkg': '#eef2ff', 'actorBorder': '#6366f1', 'actorTextColor': '#312e81', 'signalColor': '#475569', 'signalTextColor': '#1e293b', 'noteBkgColor': '#fffbeb', 'noteBorderColor': '#f59e0b', 'noteTextColor': '#78350f'}}}%%
sequenceDiagram
    autonumber
    participant Agent
    participant Script as analyze_grammar.py
    participant spaCy
    participant Wiktionary

    Agent->>Script: uv run ... MODEL -- "SENTENCE"

    rect rgba(99, 102, 241, 0.08)
    Note over Script,spaCy: Load or download the model
    Script->>spaCy: load_model(MODEL)
    alt already installed
        spaCy-->>Script: pipeline
    else needs download
        Script->>spaCy: download(MODEL)
        alt _md unavailable
            Script->>spaCy: download(_sm fallback)
        end
        spaCy-->>Script: pipeline
    end
    end

    rect rgba(20, 184, 166, 0.08)
    Note over Script,spaCy: Parse the sentence
    Script->>spaCy: nlp(SENTENCE)
    spaCy-->>Script: Doc (tokens, pos, dep, morph)
    end

    rect rgba(244, 63, 94, 0.08)
    Note over Script,Wiktionary: Concurrent fallback lookups via asyncio.gather
    par
        Script->>Wiktionary: GET definition (token, pos is X)
        Script->>Wiktionary: GET definition (token, pos is X)
    end
    Wiktionary-->>Script: definitions or 404
    end

    rect rgba(245, 158, 11, 0.08)
    Script-->>Agent: syntax analysis plus fallback definitions
    Note over Agent: writes the conversational explanation (SKILL.md Step 2)
    end

What spaCy provides

spaCy is a regular NLP library, not an LLM: its trained pipelines are deterministic statistical models, so the same sentence always gets the same tags. For "Il faut que tu le fasses.", it tags "fasses" as lemma faire, Mood=Sub|Person=3|Tense=Pres, depending on faut, which is why the subjunctive is there and not a guess pulled from memory. A wrong tag (see below) is just a wrong tag, not a made-up explanation.

This isn't retrieval-augmented generation for the grammar itself, since spaCy computes the parse and doesn't look anything up. The Wiktionary fallback is the actual RAG part: it looks up a definition for words spaCy can't classify.

Limitations

• Model quality and confidence vary by language, and there's no signal telling the agent to trust one parse less than another.
• Wrong tags look like right tags. The Wiktionary fallback only fires on POS "X" (rare); an ordinary wrong tag isn't flagged at all. In the sentence above, fr_core_news_md tags "tu" (clearly second person) as Person=1, and nothing marks it as wrong.
• Only grammar is grounded. Meaning, translation, register, and cultural nuance still come from the agent's own judgment, which can be wrong.