ielts-claude-skills: The Repo That Turns Claude Code Into an IELTS Coach
A modular skill pack for reading, writing, and speaking prep, built around routing, scoring logic, and rewrite loops that make a developer CLI feel like a personal tutor.
- The repo’s real innovation is not that it answers IELTS questions. It is that it turns Claude Code into a disciplined learning environment with a feedback loop.
- The writing skill matters most because it converts critique into a Target Score + 1 rewrite, which makes the next step visible instead of vague.
- The router and sub-skills make the system feel like software, with progressive disclosure, scoped tasks, and reusable exam flows.
- Its strongest advantage over generic prompts is structure, not novelty, because the workflow exposes the hidden mechanics of the test.
Claude Code was built for software workflows. YANZHANLIN/ielts-claude-skills uses that same interface to coach IELTS prep. That is the first useful surprise: a developer CLI becomes a study environment.
The idea works because IELTS prep is already a workflow problem. Students do not just need answers. They need diagnosis, repetition, correction, and a way to see what changed between a weak attempt and a better one.
5个自建 Claude Code Skill 覆盖雅思全科备考 | IELTS 7.5 in 2 months with AI
Why a Coding CLI Makes Sense for IELTS
The repo is not pretending Claude Code is a language app. It is exploiting what Claude Code already does well: reads instructions lazily, follows file-based structure, and handles multi-step work without collapsing into a chat blob. That makes it a better fit for coaching than a single giant prompt.
The result is more disciplined than a chatbot tab. Each skill can load only when needed, which keeps the tutor focused and makes the experience feel less like conversation and more like a guided session with a clear agenda.
The Router: One Entry Point, Four Exam Modes
# Conceptual flow
1. User enters the IELTS skill pack
2. Router gathers target score and current level
3. Router dispatches to the relevant sub-skill
4. Sub-skill runs its own scoring or practice loop
5. User returns to the router for the next taskThe central trick is simple: one entry point, then specialized flows. That keeps the system coherent without forcing the user to learn a new interface for every exam section.
This is also where the repo starts to look less like a prompt library and more like a product architecture. Routing, scope, and reuse are doing real work here.
The Writing Skill’s Real Trick: Rewrite to Target Score + 1
The writing module is the strongest proof that this is a coaching system, not a grading bot. It does not stop at diagnosis. It rewrites the essay to one level above the user’s current band, which makes the feedback concrete and usable.
| Stage | What it does | Why it matters |
|---|---|---|
| Validation | Checks word count and task alignment | Stops the model from judging the wrong thing |
| Scoring | Applies TR, CC, LR, and GRA criteria | Turns the band score into visible components |
| Annotation | Marks sentence-level weaknesses | Shows where the essay actually breaks down |
| Rewrite | Produces a Target Score + 1 version | Gives the learner an immediately reachable model |
That last step is the important one. A perfect model answer can feel unreal. A slightly better version of the student’s own essay is easier to imitate, and that is what makes the loop teachable.
The improvement loop is the product
The repo’s writing flow can be understood as a pipeline: input essay, validation, scoring, annotation, rewrite, comparison. Each stage narrows the gap between vague criticism and actual revision practice.
The design choice is pedagogically smart. It treats the learner as someone who needs a bridge, not a verdict.
Reading as Logic, Not Language
The reading skill reframes True, False, and Not Given as a mapping problem. Instead of asking the model to ‘understand’ the passage in a broad way, it forces a tighter comparison between question language and source text.
The useful move is the synonym pair table. That exposes the hidden machinery of the test. Readers stop treating the section like a vibe check and start seeing it as structured evidence matching.
| Generic IELTS prompt | This repo |
|---|---|
| Gives an answer and maybe a short explanation | Extracts the logic behind the answer |
| Treats reading as comprehension | Treats reading as mapping and evidence matching |
| Leaves review process vague | Builds review into the workflow |
| Produces a result | Produces a method |
Stateless Now, Stateful Later
The current design is intentionally stateless. That lowers friction because a user can copy the folder, run the skill, and get value without setting up persistence or local databases.
But the roadmap hints at a more powerful future. A persistent store in `~/.ielts/` would let the tutor remember mistakes, track progress, and turn one-off feedback into a longitudinal study system.
| Mode | Strength | Tradeoff |
|---|---|---|
| Stateless | Fast to start, no setup burden | No long-term memory |
| Stateful | Tracks progress over time | More complexity and maintenance |
| Current repo | Simple and portable | Session by session only |
| Future roadmap | Personalized study history | Requires local persistence |
Why This Beats Generic IELTS Prompts
A generic prompt can imitate the tone of an IELTS tutor. It cannot match the structure. That is the difference here: specialization, routing, and reusable workflows beat copy-pasted cleverness.
| Approach | Setup friction | Specialization | Feedback quality | Reuse |
|---|---|---|---|---|
| Generic prompt | Low | Weak | Inconsistent | Poor |
| Chat-based tutor | Low to medium | Medium | Better, but loose | Medium |
| This skill pack | Medium | Strong | Structured and repeatable | High |
The repo also fits the tools people already use. That matters. A tutor inside a developer CLI is weird at first, but it is also efficient for anyone who already lives in terminals and files.
What This Repo Suggests About the Future of AI Tutoring
This project points toward a broader shift. Prompt engineering is becoming packaged as domain-specific skills with narrow jobs, clear boundaries, and reusable flows.
That is a better model than one giant chatbot trying to do everything. The future looks more like small, opinionated tools that know exactly what they are for, and exactly when to get out of the way.
