Does AI Keep Getting It Wrong? Stop Explaining the Same Thing Over and Over

In short: if AI keeps producing "almost right, but not quite," the cause is often not the model but an incomplete brief. Grilling is a text instruction that makes Claude Code or Codex first ask you questions one at a time, uncover hidden assumptions, and clarify the boundaries of the task. Only then does the AI move on to execution.

You describe a task. The AI confidently delivers a result. You look at it - and it's "almost right, but not quite." You explain a second time. Then a third. You add an example, refine the wording, but again you get work that has to be redone.

Sound familiar? More often than not, the problem isn't the model - it's the brief. Half of the intent stays in your head: who the result is for, what exactly counts as success, what must not be done, and what to do in edge cases. To the AI, none of this is obvious; it's a gap, and the AI fills it with an assumption of its own.

Grilling changes the order of work: first the AI asks questions, and only then does it carry out the task.

What Grilling is in plain terms

Grilling is a short instruction in a SKILL.md file. It describes how the AI should behave before a complex or ambiguous task:

• ask one question at a time;
• wait for your answer;
• uncover hidden assumptions;
• clarify edge cases;
• suggest a recommended answer option;
• not start work until shared understanding is confirmed.

In other words, the AI stops being an executor that immediately guesses your intent and first becomes an interviewer. You answer its questions, and it gradually turns a fuzzy idea into a clear plan.

What the process looks like

1. You give the task.
2. The AI asks one clarifying question.
3. You answer.
4. The AI asks the next question, taking your previous answer into account.
5. Once no gaps remain, the AI briefly restates the shared understanding.
6. After your confirmation, it moves on to execution.

It's like briefing a good specialist: first they check what exactly needs to be done, rather than opening the editor after your first sentence.

Who benefits most from Grilling

The skill is especially useful if you:

• explain the same task to the AI several times;
• get a confident but wrong result;
• notice the AI filling in important details on its own;
• work on text, strategy, architecture, or code;
• don't want to write a long spec up front.

For a simple task like "translate this sentence," Grilling may be overkill. Its strength lies in tasks where a wrong assumption costs you a rework.

What grilling and grill-me are

The Matt Pocock Skills repository has two related files:

• `grilling/SKILL.md` - the main instruction for grilling and aligning on a plan;
• `grill-me/SKILL.md` - a short wrapper that asks the AI to run /grilling.

So these aren't two different technologies. grilling holds the core logic, while grill-me helps you trigger it manually.

Safety: what exactly gets installed

This point matters more than the install command itself.

What's safe in the skill itself

SKILL.md is a Markdown file - that is, plain text with instructions for the AI. On its own, it:

• doesn't run code;
• doesn't change files;
• doesn't connect to a server;
• doesn't read passwords, API keys, or cookies;
• doesn't execute commands directly.

Its job is to change the order of the dialogue: ask questions first, then carry out your task.

Where the risk arises

The risk begins not in the text of SKILL.md, but when files are downloaded by the installer command. So:

1. Verify the exact address of the official repository.
2. Don't copy commands from random posts and screenshots.
3. Before running a command, read what exactly it downloads and where it writes.
4. If you're not sure, first ask the AI to explain the command in plain terms.
5. After installing, review the created files and check whether the skill was actually picked up.

The universal skills CLI also has its own telemetry rules - its README states that it collects anonymous usage data. This is a separate factor worth considering if a no-telemetry mode matters to you.

Comparing installation methods

How to install in Claude Code

Option 1 - selected skills via Agent Skills

This is the most convenient option if you need exactly grilling and grill-me rather than the author's whole set:

npx skills@latest add mattpocock/skills \
  --skill grilling \
  --skill grill-me \
  --agent claude-code \
  --global

After installing, open Claude Code in a new or current session and test the call:

/grilling

Personal Claude Code skills are stored in ~/.claude/skills/<skill-name>/SKILL.md. For a single project, use .claude/skills/<skill-name>/SKILL.md.

Option 2 - the native Claude Code plugin

The author's official README also describes the plugin approach:

claude plugin marketplace add mattpocock/skills
claude plugin install mattpocock-skills@mattpocock

After this, run once:

/setup-matt-pocock-skills

This method installs the author's managed skill package. If you only need grilling, it's better to use the first method and pick specific skills.

How to install in Codex

For Codex, use the same Agent Skills installer, but specify a different agent:

npx skills@latest add mattpocock/skills \
  --skill grilling \
  --skill grill-me \
  --agent codex \
  --global

Codex supports two main ways to connect:

• user scope: ~/.agents/skills/<skill-name>/SKILL.md;
• repository scope: .agents/skills/<skill-name>/SKILL.md in your project.

For teamwork, repository scope is better: the skill sits next to the project and the whole team can see it. For personal use across different projects, user scope is more convenient.

After installing, Codex may pick up the skill automatically. If it doesn't appear in the list, restart Codex. To check explicitly, mention the skill in your request via $grilling or open the list of available skills.

The universal method via npx

The Vercel Labs Skills installer supports Claude Code, Codex, and other compatible Agent Skills tools. The general form of the command is:

npx skills@latest add mattpocock/skills \
  --skill grilling \
  --skill grill-me \
  --agent <agent-name> \
  --global

In place of <agent-name>, substitute, for example, claude-code or codex. Before running it, check the current agent names in the installer's README.

The variant without --global installs the skill at the current project's level. This is handy if you need the skill in just one repository.

Downloading the skill manually

This is the most transparent method: you first read the entire text, then copy it into the right folder yourself.

1. Open the main `grilling/SKILL.md`.
2. Open the `grill-me/SKILL.md` wrapper.
3. Check the YAML header and the instruction text.
4. Create grilling and grill-me folders in the scope you need.
5. Save the respective files under the name SKILL.md.
6. Restart the agent if it didn't detect the new folder.

For Claude Code this will be:

~/.claude/skills/grilling/SKILL.md
~/.claude/skills/grill-me/SKILL.md

For Codex in user scope:

~/.agents/skills/grilling/SKILL.md
~/.agents/skills/grill-me/SKILL.md

How to check that the skill works

Give the AI not a small command but a deliberately incomplete task, for example: "Make me a landing page for a service."

The skill is working if the AI doesn't immediately start writing the page but instead asks:

• who the landing page is for;
• what the visitor's main action is;
• what happens if the user doesn't fill out the form;
• what constraints and materials already exist.

The questions should appear one at a time. If the AI immediately produced a finished result, check whether the file is in the right folder, whether the correct scope is selected, and whether the agent sees the updated list of skills.

Honest limitations

Grilling doesn't make the model smarter and doesn't guarantee it will correctly evaluate every answer. It only helps you avoid missing important decisions at the start.

For small tasks, the extra grilling may be unnecessary. For a large strategy, architecture, a complex text, or a refactor, it often saves more time than it spends on clarification.

FAQ

Is this skill only for programmers?

No. You can use it for text, strategy, design, plans, and any task where it's important to understand the intent correctly.

Does Grilling guarantee a perfect result?

No. It reduces the risk of misunderstanding at the input stage, but the final check is still on you.

Does SKILL.md run code?

No. The file itself is a Markdown text instruction. The safety of the command you use to download it must be assessed separately.

How does grill-me differ from grilling?

grilling is the main instruction. grill-me is a short wrapper that runs /grilling.

Which should I choose: Claude Code or Codex?

Use whichever tool you already work in. The skill's logic is the same; what differs is mainly the install command, the folder, and the way you trigger it explicitly.

Can I install nothing at all?

Yes. Download SKILL.md, read it, and paste the text into your AI dialogue as an instruction. It's manual but fully transparent.

Conclusion

If you're explaining the same thing to the AI for the third time, try changing the order: let it ask you the questions first.

Grilling doesn't replace your decision and doesn't waive the review of the result. But it helps you pull out of your head the details that usually surface only after the first failed attempt.

For more practical breakdowns of AI for work and business, join the AIevgen CREATOR Telegram channel.