Grok CLI: Panduan Lengkap AI xAI di Terminal Kamu

Bayangkan kamu lagi ngerjain proyek coding, terus pengen nanya sesuatu tentang kode kamu tanpa harus buka browser, pindah ke tab lain, atau copas kode ke chatbot online. Nah, di sinilah Grok CLI masuk — alat yang bikin kamu bisa ngobrol langsung sama AI Grok dari xAI, langsung dari terminal kamu.

Intinya, Grok CLI itu semacam asisten AI yang hidup di terminal. Kamu ketik pertanyaan atau perintah, dia jawab, baca kode kamu, edit file, bahkan jalanin shell command — semua tanpa keluar dari layar hitam yang udah akrab banget buat kita yang tiap hari ngubek-ngubek kode.

Tapi ini dia yang menarik: sebenarnya ada dua hal berbeda yang orang maksud kalau nyebut "Grok CLI". Pertama, ada Grok Build — alat resmi dari xAI (perusahaan Elon Musk yang bikin Grok), yang sekarang udah ditenagai model Grok 4.5. Kedua, ada grok-cli buatan komunitas dari organisasi superagent-ai di GitHub, yang open-source dan punya ribuan bintang. Kita akan bahas keduanya, soalnya masing-masing punya kelebihan dan cocok buat kebutuhan berbeda.

Singkatnya: Grok CLI adalah alat terminal untuk berinteraksi dengan AI Grok dari xAI — baik versi resmi (Grok Build) maupun versi komunitas open-source (grok-cli dari superagent-ai). Alat ini bikin kamu bisa nanya soal kode, edit file, jalanin command, dan otomatisasi workflow langsung dari command line.

Kenapa Terminal-Based AI Itu Bikin Hidup Lebih Mudah

MUGHU ingat dulu, pertama kali cobain AI coding assistant yang berbasis browser, rasanya memang keren. Tapi lama-lama, switch antara editor dan browser itu bikin capek. Konteks hilang, fokus pecah, dan akhirnya kamu copas kode bolak-balik kayak orang ketik surat.

Terminal-based AI solver masalah itu beda. Semua jadi satu alur. Kamu di editor, buka terminal di sampingnya, ketik pertanyaan, langsung dapat jawaban yang relevan sama direktori kamu sekarang. Nggak ada lompat-lompat konteks.

Ini alasan kenapa Grok CLI — terutama varian open-source dari superagent-ai — jadi lumayan populer di kalangan developer. Repository-nya udah dikumpulin lebih dari 2.600 bintang di GitHub, dengan ratusan fork. Itu artinya komunitas merespons positif, dan ada cukup banyak orang yang merasa alat ini beneran berguna buat workflow mereka sehari-hari.

Step 1: Pahami Dulu Lanskap Grok CLI yang Sebenarnya

Sebelum install apapun, kita perlu jelas dulu apa yang mau kita pakai. Soalnya, dua "Grok CLI" ini punya asal dan karakter berbeda.

Grok Build — Versi Resmi dari xAI

Ini alat resmi yang dirilis xAI sendiri. Nama paketnya Grok Build, dan sekarang udah ditenagai model Grok 4.5. Cara installnya gampang banget — cukup satu perintah:

# Untuk macOS / Linux / WSL
curl -fsSL https://x.ai/cli/install.sh | bash

# Untuk Windows (PowerShell)
irm https://x.ai/cli/install.ps1 | iex

Grok Build ini bukan sekadar CLI biasa. Dia punya plan mode buat ngerancang perubahan kode sebelum eksekusi, subagents yang jalan paralel buat riset dan review, skills yang bisa dijadikan slash command, hooks buat jalanin script otomatis, sampai marketplace buat share plugin antar tim. Intinya, ini alat yang dirancang buat workflow development yang kompleks dan profesional.

grok-cli (superagent-ai) — Versi Komunitas Open-Source

Nah, kalau yang satu ini murni buatan komunitas. Hosted di GitHub superagent-ai/grok-cli, lisensinya MIT, dan dibangun pakai Bun plus OpenTUI (React-based terminal UI). Paket npm-nya dinamai grok-dev.

# Install via npm
npm i -g grok-dev

# Atau via Bun (recommended untuk performa terbaik)
bun install -g grok-dev

Versi ini fokus ke pengalaman terminal yang cepat dan menyenangkan. Motonya bilang "vibes and velocity" — enak dipakai dan cepat eksekusinya. Fitur andalannya termasuk sub-agents buat delegasi tugas, real-time web dan X search, sampai remote control via Telegram bot.

Tabel Perbandingan: Grok Build vs grok-cli (superagent-ai)

Nah, dari tabel di atas kamu bisa lihat kalau keduanya punya kekuatan masing-masing. Grok Build lebih lengkap fitur enterprise-nya, sementara grok-cli komunitas lebih ringan dan punya keunikan kayak Telegram remote control.

Step 2: Siapin Prasyarat Sebelum Install

Baik Grok Build maupun grok-cli komunitas, keduanya butuh beberapa hal dasar di mesin kamu. MUGHU pernah skip tahap ini dan langsung install, eh malah error soal versi Node yang keuzuran. Jadi mari kita pastikan dulu semuanya siap.

Untuk Grok Build (Resmi)

Yang kamu butuhin:

• Sistem operasi: macOS, Linux, atau Windows (WSL direkomendasiin buat Windows)

• Koneksi internet: buat download installer dan komunikasi sama API xAI

• xAI API key atau akun xAI (autentikasi via browser saat pertama kali jalan)

Kalau kamu di environment yang nggak punya browser (misalnya server headless), kamu bisa pakai API key:

export XAI_API_KEY="xai-..."

Untuk grok-cli (superagent-ai)

Yang kamu butuhin:

• Bun versi 1.0 atau lebih baru (direkomendasiin buat performa terbaik), atau Node.js versi 18 ke atas sebagai alternatif

• npm (sudah include kalau install Node.js)

• xAI API key — bisa dari console xAI

• Koneksi internet buat akses API xAI

Cek versi Bun atau Node.js kamu:

# Cek Bun
bun --version

# Cek Node.js
node --version

Output yang diharapkan:

1.1.0    # atau lebih baru untuk Bun
v20.11.0 # atau lebih baru untuk Node.js

Kalau belum install Bun, cara installnya gampang:

Baca juga OpenCode Free: Agen AI Coding Gratis dan Open Source

# macOS atau Linux
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell)
powershell -c "irm bun.sh/install.ps1 | iex"

Dapat API Key dari xAI

Ini bagian yang penting. Tanpa API key, Grok CLI nggak bisa ngobrol sama model Grok. Cara dapetinnya:

1. Buka console.x.ai

2. Daftar atau login

3. Buat API key baru

4. Copy key-nya (formatnya biasanya xai-...)

Simpan key ini baik-baik. Jangan commit ke Git atau share ke publik, ya. MUGHU pernah nggak sengaja push .env yang berisi API key ke repo publik, dan... yah, jangan tanya gimana nasib billing-nya bulan itu.

Step 3: Install Grok Build (Versi Resmi xAI)

Oke, sekarang kita masuk ke bagian praktis. Kita mulai dari Grok Build dulu soalnya ini alat resmi yang paling lengkap.

Install di macOS / Linux / WSL

curl -fsSL https://x.ai/cli/install.sh | bash

Output yang diharapkan:

Downloading Grok Build...
Installing...
✓ Grok Build installed successfully
Run 'grok' to get started.

Install di Windows (PowerShell)

irm https://x.ai/cli/install.ps1 | iex

Verifikasi Install

grok --version

Output yang diharapkan:

grok build v1.0.0

Mulai Sesi Interaktif Pertama

cd your-project
grok

Saat pertama kali jalan, Grok Build akan buka browser buat autentikasi. Kamu login pakai akun xAI, dan setelah itu dia akan simpan token-nya. Kalau kamu di environment tanpa browser:

export XAI_API_KEY="xai-..."
grok

Coba ketik prompt pertama kamu:

Explain this repo.

Atau spesifik ke file tertentu:

@src/main.rs Walk me through this file.

Grok Build akan analisa repo atau file yang kamu sebut, lalu kasih penjelasan yang kontekstual. Ini berguna banget kalau kamu baru join proyek dan mau paham struktur kode dengan cepat.

Step 4: Install grok-cli (Versi Komunitas superagent-ai)

Nah, sekarang kita install yang versi komunitas. MUGHU pribadi lebih sering pakai yang ini buat proyek-proyek harian soalnya lebih ringan dan cepat.

Install via npm

npm i -g grok-dev

Output yang diharapkan:

added 245 packages in 3s

Install via Bun (Recommended)

bun install -g grok-dev

Install dari Source (Buat yang Mau Kontribusi atau Modifikasi)

Kalau kamu mau kontribusi ke proyek atau modify sesuatu:

git clone https://github.com/superagent-ai/grok-cli.git
cd grok-cli
bun install
bun run build
bun link

Verifikasi Install

grok --version

Output yang diharapkan:

1.1.0

Konfigurasi API Key

Ada beberapa cara buat set API key. Pilih yang paling cocok sama workflow kamu.

Cara 1: Environment variable (paling gampang buat testing)

export GROK_API_KEY="xai-your-api-key-here"

Cara 2: File .env di direktori proyek kamu

echo 'GROK_API_KEY=xai-your-api-key-here' > .env

Cara 3: User settings file (paling persistent)

Buat atau edit file ~/.grok/user-settings.json:

{
  "apiKey": "xai-your-api-key-here",
  "baseURL": "https://api.x.ai/v1",
  "defaultModel": "grok-4-latest",
  "models": [
    "grok-4-latest",
    "grok-3-latest",
    "grok-3-fast"
  ]
}

MUGHU pribadi lebih suka cara ketiga soalnya setting-nya persistent across sessions. Sekali set, lupa. Nggak perlu export variable tiap buka terminal baru.

Step 5: Mulai Sesi Interaktif Pertama

Sekarang bagian seringnya — kita coba pakai!

Baca juga ClinePass: Langganan Model Open Weight untuk Coding

Sesi Interaktif Dasar

grok

Atau kalau mau spesifik ke direktori proyek tertentu:

grok -d /path/to/project

Tunggu sebentar, dan kamu bakal masuk ke interface terminal UI. Ketik pertanyaan atau perintah pertama kamu:

show me the package.json file

Grok akan baca file tersebut dan tampilkan isinya lengkap dengan penjelasan kalau perlu.

Coba yang lebih seru:

create a new file called example.js with a hello world function

Grok akan bikin file baru dengan konten yang kamu minta. Output yang diharapkan:

✓ Created example.js

function helloWorld() {
  console.log("Hello, World!");
}

module.exports = helloWorld;

Pilih Model yang Tepat

Salah satu keunggulan Grok CLI adalah kamu bisa pilih model yang sesuai kebutuhan. Kalau kamu butuh kecepatan, pakai model fast. Kalau butuh reasoning mendalam, pakai model flagship.

# Pakai model default
grok

# Pilih model spesifik
grok --model grok-4-latest

# Atau pendekatan yang lebih cepat
grok --model grok-code-fast-1

# Headless mode dengan model spesifik
grok -p "refactor this function" --model grok-code-fast-1

Berikut ringkasan model yang umum dipakai:

Intinya, kalau tugasnya berat dan butuh mikir dalam, pakai model flagship. Kalau cuma mau tanya hal simpel atau edit kecil, model fast lebih hemat waktu dan token.

Step 6: Eksplor Fitur-Feature Utama Grok CLI

Nah, di step ini kita masuk ke bagian yang bikin Grok CLI beda dari sekadar chatbot di terminal. Fitur-fitur ini yang bikin dia beneran berguna buat workflow development sehari-hari.

Plan Mode — Rancang Dulu, Eksekusi Nanti

Ini fitur yang MUGHU rasa paling berguna buat tugas kompleks. Plan Mode bikin Grok analisa kode kamu dulu, buat rencana perubahan, dan baru eksekusi setelah kamu setuju.

Di Grok Build, plan mode bisa diaktifin langsung dari TUI. Di grok-cli komunitas (versi grokcli.dev), kamu bisa masuk plan mode dengan Shift+Tab dua kali.

# 1. Start Grok CLI
grok

# 2. Press Shift+Tab twice quickly
# 3. Ask for a complex feature
"Add user authentication to this project"

# 4. Watch Plan Mode analyze your codebase safely
# 5. Review the generated implementation plan
# 6. Approve to execute or refine as needed

Kenapa ini penting? Soalnya kalau kamu langsung suruh AI edit kode tanpa rencana, kadang hasilnya nggak sesuai ekspektasi. Plan Mode bikin kamu bisa review dulu, komentar di setiap step, atau bahkan rewrite rencananya sebelum eksekusi. Ini kayak punya arsitek yang ngerancang blueprint sebelum tukang mulai bangun.

Sub-Agents — Delegasi Tugas ke Agen Khusus

Grok CLI (kedua versi) support sub-agents. Artinya, tugas besar bisa dipecah jadi bagian kecil dan dikerjain paralel.

Misalnya, kamu suruh Grok "find the source of the p99 latency regression". Grok bisa spawn beberapa sub-agent sekaligus:

• Satu agent eksplor checkout flow

• Satu agent eksplor infra dan CI

• Satu agent eksplor shared libraries

• Satu agent eksplor order services

• Satu agent eksplor fulfillment jobs

• Satu agent eksplor pricing engine

Tiap agent jalan paralel dengan context window sendiri, lalu hasilnya digabung. Ini jauh lebih cepat daripada eksplorasi satu-satu secara sequential.

Di grok-cli superagent-ai, kamu bahkan bisa define custom sub-agent di ~/.grok/user-settings.json:

{
  "subAgents": [
    {
      "name": "security-review",
      "model": "grok-code-fast-1",
      "instructions": "Prioritize security fixes. Flag any potential vulnerabilities."
    }
  ]
}

Headless Mode — Buat Script dan Otomatisasi

Ini fitur yang MUGHU paling sering pakai buat CI/CD. Headless mode bikin kamu bisa jalanin Grok CLI tanpa interaksi — satu prompt, satu output, langsung selesai.

# Single prompt, exit
grok -p "Explain this codebase"

# Dengan output format JSON buat di-pipe ke tool lain
grok -p "Explain the architecture" --output-format streaming-json

# Batasin jumlah tool rounds (default: 400)
grok --prompt "complex task" --max-tool-rounds 50

# Pipe output ke file
grok -p "analyze code" > results.txt

Ini berguna banget buat:

• CI/CD pipeline: jalanin code review otomatis sebelum merge

• Batch processing: proses multiple file sekaligus

• Scripting: embed Grok ke dalam shell script

Contoh shell script buat auto-review:

#!/bin/bash

# Auto review setiap PR
export GROK_API_KEY="xai-..."
export GROK_MODEL="grok-code-fast-1"

echo "Reviewing changed files..."
CHANGED_FILES=$(git diff --name-only origin/main...HEAD)

grok -p "Review these files for bugs and security issues: $CHANGED_FILES" \
  --max-tool-rounds 100 \
  --output-format streaming-json > review-results.json

echo "Review complete. Results saved to review-results.json"

MCP (Model Context Protocol) — Extend dengan Tool Eksternal

MCP itu semacam plugin system buat Grok CLI. Kamu bisa connect ke service eksternal kayak Linear, Sentry, GitHub, Postgres, atau browser — terus akses datanya langsung dari sesi Grok.

Baca juga Kiro Dev: IDE Agentic AWS untuk Spec-Driven Development

Di Grok Build, MCP server bekerja out of the box. Di grok-cli komunitas, ada subcommand khusus:

# Tambah MCP server
grok mcp add linear --transport sse --url "https://mcp.linear.app/sse"

# List semua MCP server yang aktif
grok mcp list

# Hapus MCP server
grok mcp remove linear

Setelah MCP server Linear terpasang, kamu bisa suruh Grok:

List semua issue yang assigned ke aku di Linear

Dan Grok akan fetch data tersebut langsung dari Linear API lewat MCP. Nggak perlu buka browser, nggak perlu copas.

Telegram Remote Control — Kontrol dari HP

Ini fitur unik yang cuma ada di grok-cli komunitas (superagent-ai). Kamu bisa pair Grok CLI dengan bot Telegram, dan kontrol dari mana saja lewat HP.

Cara setup-nya (singkat):

# Pair dengan Telegram bot
grok telegram pair

Ikuti instruksi di layar buat pair bot Telegram kamu. Setelah itu, kamu bisa kirim prompt dari HP dan Grok CLI di mesin kamu akan eksekusi. Hasilnya dikirim balik via Telegram.

MUGHU pernah pakai ini pas lagi di luar kota tapi perlu jalanin build di server kantor. Kirim pesan dari HP, Grok jalanin command, hasilnya balik ke Telegram. Bikin mungkin banget buat remote work yang ringan-ringan aja.

Step 7: Konfigurasi Lanjutan dan Customisasi

Sekarang kita bahas cara bikin Grok CLI bener-bener sesuai sama workflow kamu. Setiap developer punya kebiasaan beda, dan Grok CLI cukup fleksibel buat di-custom.

Custom Instructions via GROK.md

Kamu bisa bikin file instruksi yang Grok akan ikuti di setiap sesi. Ada dua level:

Global — ~/.grok/GROK.md:

# Global Instructions

- Always use TypeScript strict mode
- Prefer functional programming patterns
- Write tests for every new function
- Use conventional commits format

Project-level — .grok/GROK.md di root proyek:

# Project Instructions

- This project uses React 18 with TypeScript
- Use Tailwind CSS for styling
- Follow the existing component structure in src/components/
- API routes are in src/api/, use the existing middleware pattern

Project-level instructions akan override global. Jadi kamu bisa punya setting global buat hal-hal umum, dan setting per-proyek buat hal yang spesifik.

Kenapa ini penting? Soalnya kalau setiap sesi kamu harus ulang "pakai TypeScript, ikuti pattern yang udah ada, tulis test" — capek. Dengan GROK.md, sekali tulis, Grok selalu ingat. Kayak kasih memo ke kolega yang pelan tapi teliti.

Custom Models di Grok Build

Grok Build support custom model dari provider mana pun yang compatible dengan API OpenAI. Edit ~/.grok/config.toml:

[model.my-model]
model = "model-id"
base_url = "https://api.example.com/v1"
name = "Display Name"
env_key = "API_KEY"

[models]
default = "my-model"

Setelah itu, cek konfigurasi:

grok inspect

Output yang diharapkan:

Config sources:
  ~/.grok/config.toml ✓
  .grok/GROK.md ✓

Models:
  grok-4.5 (default)
  my-model

Skills:
  (none)

MCP Servers:
  (none)

Lalu pakai model custom-nya:

grok -p "Hello" -m my-model

Atau di dalam TUI, ketik /model my-model.

Project-Level Settings

Buat grok-cli komunitas, kamu bisa bikin file .grok/settings.json di root proyek:

{
  "model": "grok-code-fast-1",
  "maxToolRounds": 200
}

Ini akan override user-level settings buat proyek tersebut. Berguna kalau proyek A butuh model yang cepat, tapi proyek B butuh model yang lebih teliti.

Baca juga Codex CLI dari OpenAI: Panduan Lengkap Ngoding di Terminal

Step 8: Headless Mode dan Otomatisasi Mendalam

Oke, kita udah bahas headless mode sekilas. Sekarang kita masuk lebih dalam soal bagaimana headless mode bisa dipakai buat skenario otomatisasi yang lebih advanced.

Output Format dan Parsing

Grok Build support streaming-json output format yang sangat berguna buat parsing otomatis:

grok -p "List all functions in src/ that don't have tests" \
  --output-format streaming-json

Output-nya akan jadi stream JSON yang bisa kamu parse pakai jq atau tool lain:

{"type":"text","content":"Analyzing src/..."}
{"type":"tool_use","name":"read_file","input":{"path":"src/main.ts"}}
{"type":"text","content":"Found 3 functions without tests:\n1. processOrder() in src/orders.ts\n2. validateUser() in src/auth.ts\n3. formatPrice() in src/utils.ts"}

Integrasi dengan CI/CD

Contoh GitHub Actions workflow buat auto-review PR:

name: Grok Code Review

on:
  pull_request:
    branches: [main, develop]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Install Grok Build
        run: curl -fsSL https://x.ai/cli/install.sh | bash

      - name: Run Code Review
        env:
          XAI_API_KEY: ${{ secrets. XAI_API_KEY }}
        run: |
          CHANGED_FILES=$(git diff --name-only origin/${{ github.base_ref }}...HEAD)
          grok -p "Review these files for bugs, security issues, and code quality: $CHANGED_FILES" \
            --output-format streaming-json \
            --max-tool-rounds 100 > review.json

      - name: Post Review Comment
        uses: actions/github-script@v7
        with:
          script: |
            const review = require('fs').readFileSync('review.json', 'utf8');
            // Parse and post as PR comment
            github.rest.issues.createComment({
              ...context.repo,
              issue_number: context.issue.number,
              body: `## Grok Code Review\n\n${review}`
            });

Batch Processing Multiple Files

#!/bin/bash
# review-all-files.sh

export GROK_API_KEY="xai-..."
export GROK_MODEL="grok-code-fast-1"

for file in src/**/*.ts; do
  echo "Reviewing $file..."
  grok -p "Review this file for potential bugs and improvements: $file" \
    --max-tool-rounds 50 \
    --output-format streaming-json > "reviews/$(basename $file).json"
done

echo "All reviews complete!"

Script di atas akan review setiap file TypeScript di src/ satu per satu, simpan hasilnya di folder reviews/. MUGHU pernah pakai approach ini buat audit kode proyek lama yang belum pernah di-review. Hasilnya? Nemukan beberapa bug yang udah tidur di codebase selama berbulan-bulan.

Step 9: Studi Kasus — Migrasi Autentikasi dengan Grok CLI

Sekarang mari kita lihat contoh nyata bagaimana Grok CLI dipakai dalam skenario development yang real.

Background

Tim MUGHU waktu itu punya aplikasi web dengan ~50,000 baris kode TypeScript. Autentikasi masih pakai session-based yang lama, dan ada kebutuhan buat migrasi ke JWT dengan token rotation.

Challenge

Masalahnya, sistem autentikasi tersebar di banyak file. Ada middleware, ada route handlers, ada utility functions, ada test files. Kalau ubah satu, yang lain bisa break. Dan tim cuma punya satu akhir pekan buat migrasi.

Approach

MUGHU pakai Grok Build dengan plan mode. Langkah-langkahnya:

1. Buka Grok Build di direktori proyek

2. Aktifkan plan mode

3. Ketik prompt: Migrate auth from sessions to JWT with token rotation

Grok mulai analisa kodebase. Dia baca file autentikasi, pahami pattern yang ada, dan generate plan:

Plan: Migrate auth from sessions to JWT

1. Add jwtVerify helper in src/lib/jwt.ts
2. Add /auth/refresh with rotating refresh tokens
3. Replace session check in authMiddleware
4. Update all route handlers that use req.session
5. Migrate existing tests to JWT-based tests
6. Add backward compatibility flag (7-day window)

Estimated: 12 tool calls, ~3 minutes

Implementation

Setelah review plan dan kasih komentar di beberapa step, MUGHU approve. Grok mulai eksekusi:

• Step 1-2: Bikin src/lib/jwt.ts dengan helper jwtVerify dan jwtSign. Bersih, mengikuti pattern kode yang udah ada.

• Step 3: Update authMiddleware.ts buat cek JWT di header Authorization, fallback ke session lama kalau flag compat aktif.

• Step 4: Scan semua route handler yang pakai req.session, ganti dengan req.user yang di-derive dari JWT.

• Step 5: Update test suite. Grok bikin test baru buat JWT flow dan modify test lama.

• Step 6: Tambah environment variable AUTH_COMPAT_MODE=true buat 7-day window.

Results

• Waktu eksekusi: ~4 menit (plan + implementation)

• File berubah: 23 file

• Baris kode: +342, -178

• Bug pasca-migrasi: 0 (test suite pass semua di first try)

• Waktu manual review: ~30 menit buat verifikasi perubahan

Kalau dikerjain manual, MUGHU estimasi butuh 6-8 jam kerja, plus kemungkinan bug soal hal-hal yang terlewat. Dengan Grok CLI, total waktu dari plan sampai deploy cuma sekitar 1 jam.

Key Learnings

• Plan mode itu game-changer buat tugas yang banyak file. Review plan dulu jauh lebih murah daripada fix bug setelah eksekusi.

• Sub-agents paralel bikin analisa kodebase besar jadi cepat. Grok baca 23 file dalam hitungan detik.

• Headless mode berguna buat verifikasi pasca-implementasi. MUGHU jalanin grok -p "Verify all auth tests pass" buat double-check.

• Custom instructions di .grok/GROK.md bikin Grok ikuti convention proyek (TypeScript strict, error handling pattern, dll).

Step 10: Tips dan Trik Praktis

Setelah pakai Grok CLI beberapa bulan, MUGHU nemuan beberapa tips yang lumayan membantu.

Tips Performa

• Pakai model fast buat tugas simpel. grok-code-fast-1 jauh lebih cepat dan lebih hemat token buat edit kecil atau quick question. Simpan model flagship buat tugas yang butuh reasoning mendalam.

# Cepat buat edit kecil
grok -p "Add a comment to this function" --model grok-code-fast-1

# Teliti buat refactor besar
grok -p "Refactor the entire auth module" --model grok-4-latest

• Batas --max-tool-rounds buat tugas simpel. Default 400, tapi kalau kamu cuma nanya hal simpel, set ke 50 biar nggak ngelag.

grok -p "What does this function do?" --max-tool-rounds 10

• Pakai Bun kalau install grok-cli komunitas. Performa startup-nya memang lebih cepat dari Node.js.

Tips Workflow

• Buat GROK.md per proyek. Ini investasi kecil yang bayar besar. Tiap anggota tim yang pakai Grok CLI di proyek itu otomatis ikut convention yang sama.

• Pakai plan mode buat apapun yang ubah lebih dari 3 file. Trust me, review plan 30 detik bisa hemat jam debugging.

• Simpan prompt yang sering dipakai sebagai skill. Di Grok Build, kamu bisa capture sesi sebagai skill baru pakai /skillify. Jadi next time kamu tinggal panggil skill-nya.

Tips Keamanan

• Jangan commit API key. Selalu pakai .env atau environment variable, dan pastikan .env ada di .gitignore.

echo '.env' >> .gitignore

• Review perubahan sebelum approve. Grok CLI bisa edit file langsung. Pastikan kamu paham apa yang dia ubah sebelum save.

• Pakai sandbox kalau jalanin kode yang nggak dipercaya. Grok Build support sandboxed execution, dan grok-cli komunitas support Shuru microVM.

Step 11: Error dan Troubleshooting yang Sering Terjadi

Oke, sekarang kita bahas masalah-masalah yang sering muncul dan cara ngatasinnya. MUGHU udah kena hampir semua error ini, jadi kamu nggak perlu.

Error: GROK_API_KEY is not set

Error: GROK_API_KEY is not set. Please set your API key in ~/.grok/user-settings.json or as an environment variable.

Penyebab: API key belum di-set atau salah lokasi.

Solusi:

# Cek apakah variable sudah set
echo $GROK_API_KEY

# Kalau kosong, set ulang
export GROK_API_KEY="xai-your-key-here"

# Atau cek file user-settings
cat ~/.grok/user-settings.json

Error: Cannot find module 'grok-dev'

Error: Cannot find module 'grok-dev'

Penyebab: Paket belum ter-install global, atau path npm/bun global belum di-load.

Solusi:

# Re-install global
npm i -g grok-dev

# Cek path global
npm root -g

# Kalau pakai Bun
bun install -g grok-dev

# Pastikan path global ada di PATH
export PATH="$(npm config get prefix)/bin:$PATH"

Error: API request failed with 401

Error: API request failed with 401 Unauthorized

Penyebab: API key salah, kadaluarsa, atau nggak punya akses ke model yang diminta.

Solusi:

Baca juga CodeBuddy: Editor Kode AI untuk Coding Lebih Cepat

1. Cek API key di console.x.ai — pastikan masih aktif

2. Cek apakah model yang diminta tersedia di plan kamu

3. Cek apakah ada credit/billing yang cukup

# Test API key langsung
curl https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $GROK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "grok-4.5", "input": "Hello"}'

Error: Bun not found atau Node version too old

Error: Bun not found. Please install Bun 1.0 or later.
Error: Node.js version 18 or higher is required.

Solusi:

# Install Bun
curl -fsSL https://bun.sh/install | bash

# Atau update Node.js (via nvm)
nvm install 20
nvm use 20

Error: MCP server connection failed

Error: Failed to connect to MCP server "linear"

Penyebab: URL MCP server salah, atau service eksternal down.

Solusi:

# Cek MCP server yang terdaftar
grok mcp list

# Hapus dan tambah ulang
grok mcp remove linear
grok mcp add linear --transport sse --url "https://mcp.linear.app/sse"

# Test koneksi manual
curl -I "https://mcp.linear.app/sse"

Error: Grok CLI lambat atau hang

Penyebab: Bisa jadi karena model yang dipilih terlalu berat buk tugas simpel, atau koneksi internet nggak stabil.

Solusi:

• Ganti ke model yang lebih cepat: grok --model grok-code-fast-1

• Kurangi --max-tool-rounds ke 50 atau kurang

• Cek koneksi internet ke api.x.ai

• Kalau masih lambat, coba restart terminal dan clear cache

Error: File tidak terbaca atau tidak ditemukan

Error: File not found: src/components/Button.tsx

Penyebab: Path relatif salah, atau kamu belum set working directory yang benar.

Solusi:

# Selalu set working directory
grok -d /path/to/project

# Atau pakai absolute path di prompt
grok -p "Read /Users/mughu/projects/myapp/src/components/Button.tsx"

Step 12: Perbandingan Detail — Grok Build vs grok-cli vs Alternatif Lain

Biar lebih jelas, mari kita bandingkan tidak hanya dua varian utama, tapi juga beberapa alternatif lain yang ada di ekosistem.

Rekomendasi per Use Case

Buat tim dan enterprise: Grok Build adalah pilihan paling solid. Marketplace, hooks, deep worktree support, dan plan mode yang mature bikin cocok buat workflow tim yang kompleks.

Buat developer solo yang suka open-source: grok-cli dari superagent-ai. Ringan, cepat, punya fitur unik kayak Telegram remote control, dan komunitasnya aktif.

Buat yang pengen coba plan mode tanpa ribet: grok-cli dari grokcli.dev. Install-nya gampang, dan plan mode-nya lumayan intuitive buat eksplorasi kode.

Buat query simpel dan cepat: grok-cli dari mmoz-root. Minimalis, nggak banyak fitur, tapi cukup buat nanya soal kode dengan cepat.

Step 13: Integrasi dengan Workflow Development Sehari-hari

Nah, sekarang kita bahas bagaimana Grok CLI masuk ke dalam rutinitas coding kamu sehari-hari. Bukan cuma soal install dan pakai, tapi soal bagaimana bikin alat ini beneran jadi bagian dari workflow.

Eksplorasi Codebase Baru

Kalau kamu baru join proyek atau clone repo baru, ini cara MUGHU pakai Grok CLI buat paham kode:

cd new-project
grok

# Lalu ketik:
"Explain this repo. What's the architecture and how do the main components interact?"

Grok akan scan struktur direktori, baca file-file penting, dan kasih overview yang kontekstual. Jauh lebih cepat daripada baca README lalu trace kode satu-satu.

Code Review Sebelum Commit

# Review perubahan yang belum di-commit
grok -p "Review my uncommitted changes. Check for bugs, security issues, and style violations."

# Atau review PR sebelum push
grok -p "Review all changes compared to main branch. Suggest improvements."

Debug dan Troubleshooting

grok

# Lalu ketik:
"I'm getting this error: TypeError: Cannot read property 'map' of undefined at src/components/List.tsx:15. Help me debug."

Grok akan baca file yang dimaksud, analisa error, dan sering kali langsung kasih solusi atau setidaknya arahin kamu ke akar masalah.

Generate Test

grok -p "Generate unit tests for src/utils/formatPrice.ts. Cover edge cases like null input, negative numbers, and currency formatting."

Refactor

grok -p "Refactor src/api/handlers.ts to use the repository pattern. Extract database logic into separate files."

Dengan plan mode, kamu bisa review rencana refactor dulu sebelum Grok mulai ubah kode. Ini krusial buat refactor besar soalnya kamu bisa pastikan arsitektur baru sesuai visi kamu.

Step 14: Best Practices dan Hal yang Perlu Diwaspadai

Setelah pakai Grok CLI cukup lama, ada beberapa hal yang MUGHU pelajarin — baik best practices maupun hal yang perlu diwaspadai.

Best Practices

• Selalu review perubahan sebelum save. Grok CLI itu alat yang powerful, tapi "powerful" itu pedang bermata dua. Selalu paham apa yang dia ubah sebelum approve.

• Pakai plan mode buat perubahan besar. Investasi 30 detik buat review plan bisa hemat jam debugging.

• Buat GROK.md yang baik. Instruksi yang jelas = output yang lebih konsisten. Spesifikin convention, pattern, dan aturan proyek kamu.

• Pantau penggunaan API. API Grok itu berbayar. Pantau credit usage di console xAI biar nggak kaget pas tagihan.

• Pakai sub-agents buat tugas yang bisa di-paralel. Kalau ada 5 file yang harus di-review, jangan review satu-satu. Spawn 5 sub-agent, jalan paralel, selesai dalam hitungan menit.

Hal yang Perlu Diwaspadai

• Jangan trust 100%. Grok CLI, seperti AI tool manapun, bisa salah. Selalu verify perubahan, terutama yang menyangkut logika bisnis kritis.

• Hati-hati dengan file sensitif. Kalau proyek kamu punya file yang berisi data sensitif (credential, key, PII), pastikan Grok nggak bocor ke tempat yang nggak seharusnya.

• API key kebocoran. MUGHU nggak capek ngulang ini: jangan commit API key. Pakai .env, tambah ke .gitignore, dan rotate key kalau pernah bocor.

• Dependency pada AI yang berlebihan. Grok CLI itu alat, bukan pengganti pemahaman. Kalau kamu nggak paham kode yang dia tulis, itu tanda bahaya. Pelajari, tanya kenapa, jangan cuma accept.

• Kompatibilitas versi. grok-cli komunitas pernah ngalamin periode nggak update (November 2025 sampai early 2026) yang bikin ada masalah kompatibilitas API. Meskipun sekarang udah aktif lagi, tetap pantau update dan issue di repository.

Step 15: Masa Depan Grok CLI dan Keseruan Lainnya

Grok CLI, baik versi resmi maupun komunitas, terus berkembang. xAI udah rilis Grok 4.5 yang sekarang ngepowern Grok Build, dan model-model baru terus dikembangkan.

Beberapa hal yang menarik buat dipantau:

Baca juga GitHub Copilot: Cara Mempercepat Kerja Tim

• IDE integration: Ada roadmap buat VS Code extension dan Vim plugins. Ini akan bikin Grok CLI lebih terintegrasi dengan editor yang kita pakai sehari-hari.

• Marketplace ecosystem. Grok Build punya marketplace buat share plugin antar tim. Ini bisa jadi game-changer buat organisasi yang mau standardize AI workflow.

• Model yang lebih cepat dan lebih murah. xAI terus rilis varian fast yang lebih efisien. grok-code-fast-1 udah lumayan cepat, bayangin kalau ada yang 2x lebih cepat lagi.

• MCP ecosystem yang berkembang. Makin banyak service yang support MCP, makin powerful Grok CLI jadinya. Bayangin connect ke Jira, Figma, atau bahkan database lokal langsung dari terminal.

Nah, buat Teman-Teman yang tertarik eksplor lebih lanjut, ada beberapa resource yang bisa dijelajahi:

• Dokumentasi resmi Grok Build buat panduan lengkap fitur resmi

• Repository grok-cli di GitHub buat kontribusi atau lihat source code

• xAI API documentation buat pahami API yang menjadi dasar Grok CLI

• Konsep Model Context Protocol buat pahami cara MCP bekerja

Tips Akhir biar Makin Pede Pakai Grok CLI

Sebelum kita tutup, MUGHU mau share beberapa tips tambahan yang nggak masuk kategori step di atas tapi tetap penting.

Eksperimen dengan prompt. Cara kamu nanya ke Grok CLI mempengaruhi kualitas jawaban. Daripada "fix this bug", coba "this function throws TypeError when input is null. Find the root cause and suggest a fix with proper error handling." Makin spesifik, makin bagus hasilnya.

Pakai @ buat referensi file. Di Grok Build, kamu bisa pakai @path/to/file buat arahin perhatian Grok ke file spesifik. Ini lebih efisien daripada nulis path panjang di prompt.

@src/components/Dashboard.tsx Why is this component re-rendering on every state change?

Kombinasikan dengan tool lain. Grok CLI nggak harus dipakai sendirian. MUGHU sering kombinasikan dengan ripgrep buat search, fzf buat fuzzy finder, dan tmux buat multi-pane. Terminal jadi semacam command center yang lengkap.

Jangan takut salah. Grok CLI punya session persistence. Kalau kamu nggak sengaja suruh dia ubah sesuatu yang salah, kamu bisa undo di editor atau pakai git. Itulah kenapa selalu commit sebelum operasi besar.

Belajar dari komunitas. Repository grok-cli superagent-ai punya 11+ kontributor dan ratusan fork. Baca issue dan PR di sana bisa kasih insight buat use case yang mungkin belum kepikiran.

Nah, Teman-Teman, itu dia perjalanan kita eksplor Grok CLI dari A sampai Z. Dari ngerti lanskapnya, install, konfigurasi, sampai pakai buat tugas development sehari-hari. Semoga artikel ini bermanfaat dan bikin kamu makin pede buat cobain sendiri di proyek kamu. Selamat ngoding dan sampai jumpa di tutorial berikutnya!

Studi Kasus: Migrasi Project Laravel dari versi 10 ke 11 dengan Grok CLI

Biar makin kebayang gimana Grok CLI kerja di dunia nyata, MUGHU mau share pengalaman pribadi pas migrasi project Laravel dari versi 10 ke 11 kemarin. Ini bukan kasus main-main — projectnya punya 40+ controller, 15 middleware, dan dependency yang lumayan banyak.

MIGHU mulai dengan command sederhana:

grok -p "Analyze this Laravel 10 project and list all breaking changes needed for Laravel 11 migration. Check composer.json, app/Http/Kernel.php, and all service providers."

Grok CLI nge-scan seluruh codebase dalam sekitar 30 detik, lalu ngeluarin laporan yang cukup detail. Dia nemuin bahwa app/Http/Kernel.php udah deprecated di Laravel 11, beberapa middleware harus pindah ke bootstrap/app.php, dan ada 3 package yang versinya perlu di-upgrade.

Langkah berikutnya, MUGHU suruh dia bikin perubahan secara bertahap:

grok -p "Migrate this project to Laravel 11. Start by updating composer.json, then move middleware registration to bootstrap/app.php. Show me each change before applying."

Yang bikin MUGHU seneng adalah Grok CLI nggak langsung ubah semua sekaligus. Dia nanya konfirmasi tiap perubahan, jadi MUGHU bisa review dan skip yang nggak perlu. Total migrasi selesai dalam 2 jam — bandingkan sama kalau manual yang biasanya makan 1-2 hari.

Grok CLI vs Tools Coding AI Lain

Teman-Teman mungkin nanya, "bedanya sama Cursor atau GitHub Copilot apa?" Pertanyaan bagus. MUGHU udah coba ketiganya dan ini perbandingannya.

Cursor itu IDE-based. Kamu harus pindah editor ke Cursor IDE. Kelebihannya, integrasi dengan editor sangat erat — inline edit, autocomplete kontekstual, semuanya mulus. Tapi kalau kamu udah invest di VS Code setup atau Neovim dengan konfigurasi rumit, pindah editor cuma buat AI terasa berat.

GitHub Copilot kerjanya di dalam editor sebagai extension. Autocomplete-nya kenceng banget dan ngerti konteks file yang lagi kamu buka. Tapi buat tugas yang butuh multi-file reasoning atau operasi terminal-level (kayak install package, jalanin migration, setup config), Copolio nggak bisa bantu banyak.

Grok CLI kerjanya di terminal. Dia bisa baca seluruh project, jalanin command, edit multiple file sekaligus, dan punya akses ke MCP server buat connect ke service eksternal. Untuk tugas yang butuh "big picture" — kayak refactor arsitektur, migrasi versi, atau setup project dari nol — Grok CLI unggul. Tapi buat autocomplete real-time saat ngetik, Copilot masih juara.

MUGHU personally pakai keduanya: Copilot buat ngetik kode sehari-hari, Grok CLI buat tugas berat yang butuh analisis menyeluruh.

Integrasi MCP: Bikin Grok CLI Connect ke Apa Saja

Salah satu fitur yang MUGHU paling sering pakai adalah MCP (Model Context Protocol). Ini protokol yang bikin Grok CLI bisa connect ke service eksternal. Konfigurasinya cukup simpel — bikin file mcp.json di root project kamu:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://localhost/mydb"
      }
    }
  }
}

Setelah itu, Grok CLI bisa langsung baca issue dari GitHub, bikin PR, atau query database Postgres tanpa keluar dari terminal. MUGHU pernah pakai ini buat trace bug yang cuma muncul di production — suruh Grok CLI query data production (read-only tentunya), bandingin sama data local, dan nemuin root cause dalam 10 menit.

Baca juga Mengenal Astro 7.1: Framework JavaScript Ringan untuk Website

Buat Teman-Teman yang mau eksplor MCP lebih jauh, dokumentasi resmi di modelcontextprotocol.io cukup lengkap. Ada list server yang udah ready-made buat Slack, Google Drive, Brave Search, dan banyak lagi.

Performance Tuning: Biar Grok CLI Makin Ngebut

Grok CLI secara default udah cepet, tapi ada beberapa trik biar makin ngebut.

Pilih model yang pas. Grok 4.5 paling pintar tapi paling lambat. Buat tugas simpel kayak generate boilerplate atau format code, pakai model fast yang lebih murah dan cepat. Simpan Grok 4.5 buat tugas yang butuh reasoning kompleks.

Batasi konteks file. Kalau project kamu gede banget, Grok CLI bisa lambat karena dia baca semua file. Pakai .grokignore buat exclude file yang nggak perlu di-scan:

node_modules/
dist/
build/
*.min.js
*.map
coverage/
.env

Pakai caching. Grok CLI punya built-in caching buat file yang udah di-scan. Kalau kamu nggak ubah file tertentu, dia nggak akan baca ulang. Pastikan caching aktif di konfigurasi:

[cache]
enabled = true
max_size_mb = 500

Paralel sub-agents. Ini trik advanced yang MUGHU pakai sering. Kalau ada multiple task yang independent — kayak review 3 module berbeda — suruh Grok CLI spawn sub-agent buat masing-masing. Jalan paralel, selesai 3x lebih cepat.

Troubleshooting: Masalah Umum dan Solusinya

MUGHU udah pakai Grok CLI cukup lama buat tahu masalah-masalah yang sering muncul. Ini listnya dan cara ngatasinnya.

"Authentication failed" padahal API key udah benar. Cek apakah API key kamu udah expired atau rate-limited. Buka console xAI, lihat status key. Kadang key perlu di-regenerate kalau udah lama nggak dipakai.

Grok CLI lemot di project gede. Tambahin .grokignore buat reduce file yang di-scan. Kalau project punya banyak file generated (kayak dist/ atau build/), exclude semua.

Hasil generate nggak konsisten. Suhu model bisa di-adjust di konfigurasi. Suhu rendah (0.2-0.3) bikin jawaban lebih deterministik, suhu tinggi (0.7-0.9) bikin lebih kreatif tapi kadang nggak stabil.

MCP server nggak connect. Pastikan dependency MCP server udah terinstall. Kalau pakai npx, coba jalanin manual dulu buat pastiin nggak ada error: npx @modelcontextprotocol/server-github.

Memory usage tinggi. Grok CLI bisa makan RAM cukup banyak di project gede. Tutup aplikasi lain yang nggak perlu, atau set memory limit di konfigurasi:

[performance]
max_memory_mb = 2048

Workflow Harian MUGHU dengan Grok CLI

Biar makin kebayang, ini workflow harian MUGHU pakai Grok CLI di project nyata.

Pagi, sebelum mulai ngoding, MUGHU jalanin grok inspect buat lihat status project — ada issue yang pending, ada file yang berubah semalam, ada dependency yang perlu update. Ini kayak minum kopi pagi tapi buat codebase.

Siang, pas lagi ngoding, MUGHU pakai Grok CLI buat tugas-tugas berat: generate function yang kompleks, refactor module yang udah berantakan, atau trace bug yang susah. Untuk ngetik kode line-by-line, Copilot masih jadi andalan.

Sore, sebelum commit, MUGHU suruh Grok CLI review semua perubahan hari ini. Kadang dia nemuin hal-hal yang MUGHU lewatin — variable yang nggak dipakai, error handling yang kurang, atau potential security issue.

Malam (kalau masih ngoding), MUGHU pakai buat generate test dan dokumentasi. Test dan docs itu dua hal yang sering di-skip pas deadline ngejar, tapi dengan Grok CLI, 10 menit udah selesai semua.

Pertanyaan yang Sering Muncul

Apakah Grok CLI gratis?

Tidak. Grok CLI butuh API key xAI yang berbayar. Tapi biaya per token-nya kompetitif, dan buat project kecil sampai menengah, biayanya masih masuk akal. Pantau usage di console xAI biar nggak kaget.

Bisa pakai model selain Grok?

Baca juga 9Router v0.5.35: Solusi Rate Limit AI Coding

Bisa. Grok Build support custom model. Tinggal tambahin konfigurasi di ~/.grok/config.toml dengan base URL dan API key provider lain. MUGHU pernah coba pakai model lokal via Ollama dan tetap jalan.

Apakah aman buat project komersial?

Aman, selalu kamu ikutin best practice. Jangan commit API key, pakai .grokignore buat exclude file sensitif, dan review setiap perubahan sebelum push. xAI punya policy soal data usage yang bisa kamu baca di dokumentasi resmi.

Bisa pakai di Windows?

Bisa. Ada installer PowerShell khusus Windows: irm https://x.ai/cli/install.ps1 | iex. Tapi MUGHU personally lebih suka pakai WSL2 buat pengalaman yang lebih mulus, soalnya beberapa dependency MCP server lebih gampang jalan di environment Linux.

Kesimpulan

Setelah ngelewatin semua setup, troubleshooting, sama workflow harian, jelas kalau Grok CLI bukan sekadar tool AI biasa yang ngejawab pertanyaan. Ini lebih kayak nambah anggota tim baru — yang bisa inspect codebase, generate function kompleks, review perubahan, bahkan bikin test dan dokumentasi dalam waktu singkat. Yang bikin MUGHU betah adalah fleksibilitasnya: bisa custom model, bisa atur suhu, bisa exclude file, dan yang paling penting, nggak dipaksa pakai satu cara doang.

Tapi jujur, Grok CLI juga bukan silver bullet. Ada learning curve, ada biaya API yang harus di-monitor, dan ada momen-momen di mana Copilot atau ngetik manual masih lebih efisien. Kuncinya adalah tau kapan harus pakai dan kapan harus skip. Kalau kamu udah paham workflow-nya — inspect di pagi, heavy lifting di siang, review di sore, docs di malam — produktivitas kamu bakal naik signifikan tanpa harus ngorbanin kualitas kode.

Buat kamu yang masih ragu, coba aja pakai di project kecil dulu. Install, setup API key, konfigurasi .grokignore, dan biarin dirimu eksplor. Pengalaman MUGHU menunjukkan bahwa tool ini paling keliatan nilainya pas kamu udah invest waktu buat ngerti konfigurasinya — bukan pas pertama kali jalanin dan langsung expect magic. Kalau kamu mau baca dokumentasi resmi dan eksplor fitur lain yang belum dibahas di sini, langsung aja kunjungi dokumentasi xAI.

Grok CLI udah ngebuktiin dirinya sebagai tool yang worth di-integrate ke workflow developer Indonesia. Sekarang giliran kamu buat cobain dan rasain sendiri bedanya. Selamat ngoding!

Referensi

Grok CLI. (2026). Conversational AI CLI Tool.

Grok CLI. (2026). Open Source Terminal AI Assistant with Plan Mode.

xAI. (2026). Grok Build.

GitHub. (2026). Grok-CLI: An Open-Source Coding Agent for the Grok API.

Grok CLI. (2026). Quickstart Guide.

xAI Docs. (2026). Grok Build Overview.

Grokipedia. (2026). Grok CLI.

GitHub. (2026). Grok CLI: A Command-Line Interface for xAI's Grok Models.

Grok. (2026). Grok AI Assistant.

DeepWiki. (2026). Superagent-AI Grok-CLI: An Open-Source Conversational AI Coding Agent.

Baca juga Cursor Composer 3: AI Coding 1,5T Parameter Segera Rilis