How to Create Custom Skills for Codex: The grill-me Design Pattern

Apr 1, 2026

Purpose

I wanted to create custom skills for my Codex workflow. Then I found the grill-me skill - just 5 sentences that changed how I plan features. The skill achieved a 90% success rate. So I asked: why does such a minimal skill work so well?

The grill-me skill content:

Interview me relentlessly about every aspect of this plan until we reach
a shared understanding. Walk down each branch of the design tree, resolving
dependencies between decisions one-by-one. For each question, provide your
recommended answer.

Ask the questions one at a time.

If a question can be answered by exploring the codebase, explore the
codebase instead.

That’s it. No complex logic, no branching, no conditions. Just clear instructions that override AI’s default “generate” behavior.

What I Learned from grill-me

The Reddit thread had a top comment (19 score): “Wow, that’s a tiny skill”

I had the same reaction. The joke response (17 score): “It’s not about the size it’s about how you use it, okay!?”

But the joke is actually right. The skill works because it does 4 things:

Sets interview mode - Explicitly tells AI to ask questions, not generate code
One at a time - Prevents AI from dumping 20 questions at once
Self-answer - AI explores codebase instead of asking me things it can find itself
Termination - Ends when “shared understanding reached”

The key insight: AI coding assistants default to generating. Your skill needs to override that default.

The Design Pattern

I call this the “behavior override” pattern. Here’s how it works:

Default: AI generates immediately
Override: AI interviews first

Default: AI guesses architecture
Override: AI explores codebase first

Default: AI makes assumptions
Override: AI asks for specifics

The skill doesn’t need complex logic. It just tells AI which mode to enter.

How to Create Your Own Skill

Step 1: Identify the Behavior to Override

What default AI behavior annoys you?

What AI Does	What I Want
Generate immediately	Interview first
Add extra features	Confirm scope before
Guess patterns	Explore codebase first
Make assumptions	Ask specifics
Single pass	Iterate with feedback

I pick one behavior to override per skill.

Step 2: Write 3-5 Sentences

grill-me is 5 sentences. I follow that pattern:

---
name: [skill-name]
description: [when to use - triggers skill invocation]
---

# [Skill Name]

[Behavior override - 1-2 sentences]

[Process instruction - 1-2 sentences]

[End condition - 1 sentence]

Step 3: Test and Refine

I test on 3 tasks. If AI deviates, I add 1 sentence. Not 10 sentences. Just 1.

My Custom Skills

I created these skills using the grill-me pattern:

Edge Case Hunter

---
name: edge-case-hunter
description: Find edge cases before implementing. Use for user-facing features.
---

# Edge Case Hunter

Before implementing, hunt for edge cases with me.

Ask about: null inputs, empty states, concurrent access, permission boundaries.

One edge case at a time. Continue until we've covered the critical ones.

Pattern Follower

---
name: pattern-follower
description: Follow existing codebase patterns. Use when adding to established code.
---

# Pattern Follower

First, explore the codebase to find similar implementations.

Identify: naming patterns, file structure, error handling style, testing approach.

Propose an approach that matches those patterns. Wait for confirmation.

Scope Guard

---
name: scope-guard
description: Prevent scope creep. Use when AI tends to add unwanted features.
---

# Scope Guard

Before generating, confirm the exact scope with me.

List what you will implement. Ask if anything extra is wanted.

Only implement confirmed items. Say "scope confirmed" before coding.

Each skill is under 5 sentences. Each has a clear end condition.

Where to Put Skills

Skills live in skill directories:

Project-level:  .claude/skills/[skill-name]/SKILL.md
Global-level:   ~/.claude/skills/[skill-name]/SKILL.md

I use project-level for workflow-specific skills. Global-level for skills I use across projects.

The Reason Minimal Skills Work

I think the key reason is: AI responds to clear mode instructions.

When I write complex skills with conditionals:

If the task involves database changes:
  1. First ask about migration strategy
  2. Then ask about rollback plan
  3. Then ask about...

If the task involves API changes:
  1. First ask about...
[Too many branches - AI picks wrong one]

AI gets confused by too many options.

When I write minimal skills:

"Before database changes, ask me about migration strategy and rollback plan"

AI follows the single clear instruction.

The Reddit users expected complexity. The reality: simple beats complex.

Summary

In this post, I showed how to create custom Codex skills using grill-me’s design pattern. The key point is: minimal skills work because they override AI’s default behavior with clear mode instructions.

The pattern:

Identify behavior to override
Write 3-5 sentences
Include termination condition
Test and add 1 sentence if needed

grill-me proved that 5 sentences can transform workflow. No need for complex logic.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 grill-me skill source
👨‍💻 Reddit Discussion: I tried the grill-me skill

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!