How to use everything-claude-code with Grok (xAI)? Best practices for agents & skills?

[haiporsche]

Hi everyone,

First of all — huge thanks to @affaan-m and the whole team!

I'm currently using Grok (from xAI) instead of Claude Desktop / Cursor / OpenCode. I know the repo is built specifically for Claude with the .claude/, .cursor/, .opencode/ folders, rules, hooks, and auto-loading.

I tried the manual way:

• Copy-paste content from agents/*.md + skills/*.md + rules/ into my prompt
• Ask Grok to role-play as specific agents (e.g. planner, refactor-cleaner, code-reviewer) + load specific skills (e.g. tdd-workflow, hexagonal-architecture)

It works surprisingly well, but I feel like I'm not using it at 100% potential.

My questions for the community:

1. Has anyone successfully adapted this repo for Grok?
2. What's the best workflow? (e.g. copy specific folders first? Create a single "master prompt"? Use Grok's custom instructions?)
3. Any tips for making agents, skills, commands (/plan, /code-review, /tdd...), and hooks work smoothly with Grok?

I'm happy to test anything and report back. Just want to get that full "pro coding vibe" with Grok too!

Thanks in advance 🙏

[Nickalus12]

The main hurdle with Grok right now is the lack of native project-level config like .cursorrules or the .claude/ auto-loading.

Your best bet for that "pro vibe" is using a context packer like repomix to flatten the specific rules/, skills/, and agents/ folders into a single context file. Instead of manual copy-pasting every time, you feed the packed file at the start of the session.

For the commands and hooks, I've found Grok-2 responds best when you explicitly define the "Command Registry" in the System Instructions (Custom Instructions). Something like:

# Command Registry
- /plan: Execute [planner] agent logic from the provided context.
- /tdd: Apply the [tdd-workflow] skill.
- /review: Run [code-reviewer] agent.

If I use a command, strictly follow the corresponding logic in the loaded skills/agents.

IIRC, Grok handles XML tags better than raw markdown for complex instructions. Try wrapping the skills in tags like <skill name="tdd-workflow">...</skill> in your packed context. It helps the model distinguish between your code and the "system" skills it's supposed to use.

One gotcha: Grok’s context window is huge, but it can lose the "instincts" from the rules/ folder if they aren't at the very end of your system prompt. I'd put the rules/global.md content at the bottom of your Custom Instructions so they stay "top of mind" for the model.

lmk if the command mapping helps—Grok is usually pretty literal with those once defined.

[affaan-m]

Grok is not a first-class ECC harness today, so the best current model is to treat ECC as a source kit rather than expecting native .claude-style auto-loading.

What works best in practice right now:

• keep deterministic constraints in a smaller rule/context pack instead of dumping the whole repo every session
• load only the specific agents/skills/commands you actually need for the task
• define a lightweight command registry in your system/custom instructions so /plan, /review, /tdd, etc. have stable meanings
• keep broader workflow playbooks as on-demand context rather than always-on prompt ballast

So the split is roughly:

• rules / invariants -> always-on packed context
• skills / workflows -> loaded only when relevant
• commands -> mapped explicitly in your system prompt or reusable starter context

If you want the closest thing to "full ECC with Grok" today, I would:

1. build a small harness-specific starter pack from the ECC rules/instructions you use every session
2. keep a second pack of deeper skills and agent prompts you can paste or attach selectively
3. standardize your command aliases so Grok sees the same command vocabulary every time

We also have a backlog item open for broader non-native harness guidance, because this question keeps coming up. The short answer is: yes, ECC can still help a lot with Grok, but right now it is a selective-port workflow, not a native one-click install surface.