In partnership with

Typing is a thing of the past

Typeless turns your raw, unfiltered voice into beautifully polished writing - in real time.

It works like magic, feels like cheating, and allows your thoughts to flow more freely than ever before.

With Typeless, you become more creative. More inspired. And more in-tune with your own ideas.

Your voice is your strength. Typeless turns it into a superpower.

Download for Mac today

Grok + xAI Prompting Guide (friendly, fast, and practical)

You’ve got Grok. Now make it work like a teammate. Here’s a punchy, hands-on guide to prompting Grok—especially grok-code-fast-1—so you ship fixes and features faster with fewer retries.

0) Quick mental model: pick the right Grok

• Use grok-code-fast-1 for agentic coding (navigate codebases, call tools, implement changes). It’s built to run tools during its “thinking,” and it favors quick, iterative loops. (xAI Docs)

• Use Grok 4 for one-shot Q&A and deep reasoning when you already have all the context ready. (xAI Docs)

1) Golden prompt formula (works in chat or API)

System (one-time guardrails)

• Role, mission, boundaries, success criteria.

• Tooling rules (what you may call, when, and how you should verify).

• Output contract (schema, file diffs, test names, etc.).
  Tip: A strong system prompt moves the needle a lot. (xAI Docs)

User (task request)

• Context: paste the relevant files, paths, dependencies. Name them clearly (e.g., @errors.ts, @sql.ts). Avoid dumping the entire repo. (xAI Docs)

• Goal & requirements: explicit, testable outcomes. (e.g., “Add structured error codes and handle timeout + connection errors. Update unit tests.”) (xAI Docs)

• Constraints: performance ceilings, compatibility, coding style.

• Acceptance checks: how we’ll verify (tests to pass, CL output, benchmark target).

• Refine: if v1 misses, point to the exact failure and ask for a targeted fix. (xAI Docs)

Formatting that helps

• Use Markdown or XML-style sections to label context blocks. Grok is accustomed to lots of initial context and benefits from clearly marked sections. (xAI Docs)

2) Copy-paste templates

A) System prompt (agentic coding)

You are a senior engineer acting inside my IDE with tool access.
Goals: implement requested changes safely, produce minimal diffs, and pass tests.
Constraints: keep complexity low; preserve public APIs; follow repo style.
When unsure, ask clarifying questions briefly.
Use tools when they reduce risk (tests, search, run commands).
Output: 
1) brief plan, 2) patch/diff per file, 3) tests/commands to run, 4) risks & rollbacks.

Add any repo-specific rules here (linting, error codes, logging style).

B) User prompt (with labeled context)

# Task
Add structured error handling to db queries in @sql.ts. 
Use error codes defined in @errors.ts. Ensure retries and timeouts are handled.

# Requirements
- Map DB errors to specific codes
- Add retry with backoff for transient failures
- Ensure non-blocking behavior in the main thread

# Context
## File: @errors.ts
[...relevant excerpt only...]

## File: @sql.ts
[...relevant excerpt only...]

# Acceptance
- Unit tests updated/added and passing
- Example query path documented
- Quick benchmark shows no regression

# Next step
Provide a minimal diff and the test plan first. Then propose the patch.

3) Tool calling: use native function calls

grok-code-fast-1 was designed for native tool calling—prefer it over XML/JSON-in-text hacks. In streaming mode you can also access reasoning traces via reasoning_content for better UX/debugging. (xAI Docs)

Minimal JS example

const tools = [{
  type: "function",
  function: {
    name: "run_tests",
    description: "Run project tests",
    parameters: { type: "object", properties: { suite: {type:"string"} }, required: ["suite"] }
  }
}];

const res = await client.chat.completions.create({
  model: "grok-code-fast-1",
  messages: [{role:"system", content:"You can call tools when needed."},
             {role:"user", content:"Add error handling to @sql.ts; then run unit tests."}],
  tools,
  stream: true // enables reasoning_content in streaming
});

See xAI function-calling guide and cookbook for more patterns. (xAI Docs)

4) Cache-friendly speedups (cheap + fast)

• Keep a stable conversation prefix across tool sequences so Grok hits the cache more often (that’s a big part of Code Fast’s speed). Avoid rewriting the whole history every turn. (xAI Docs)

• xAI bills cached input tokens at a lower rate—design prompts to reuse stable scaffolding. (xAI Docs)

5) What “good” looks like (from xAI’s guide)

• Bad: “Make error handling better.”

• Good: “Error codes live in @errors.ts. Use them to add proper handling to @sql.ts queries.” (xAI Docs)

• Bad: “Create a food tracker.”

• Good: “Create a food tracker that shows daily calories by nutrient when I enter a food; include an overview and trend view.” (xAI Docs)

• Refinement example: “The previous approach blocks the main thread; move IO to its own thread loop instead of the async-lib version.” (xAI Docs)

6) Recipe cards (steal these)

Add structured logging

• Ask: “Insert structured logs at key boundaries in @payments/*.ts (start/end, error, retry). Keep PII out. Emit JSON lines.”

• Accept: “Show a diff + sample log lines + a grep command to verify.”

Write tests before refactor

• Ask: “Add unit tests for calculateQuote() edge cases (null, negative, large input). Then refactor for readability without behavior change.”

• Accept: “Green tests; no API changes; cyclomatic complexity ≤ N.”

Performance fix

• Ask: “Our bottleneck is parseEvents() in events.ts. Profile and propose 2 alternatives; implement the faster one within 5% memory budget.”

• Accept: “Include micro-benchmark snippet + expected output.”

Migrations

• Ask: “Add a users.deleted_at column (nullable), backfill from archived_users. Provide migration + rollback + test.”

• Accept: “Idempotent migration; rollback tested; PR checklist.”

7) Safety + ops hygiene (keep agents out of trouble)

• Use a trust hierarchy: user/system > retrieved docs > web pages. Don’t let external content silently override system rules (protect against indirect prompt injection). (The Wall Street Journal)

• Limit and audit tool permissions; prefer read-only by default.

• Log tool calls + inputs/outputs; add rate limits/backoff for flaky integrations (general Grok 4 deployment best practices). (Oracle Docs)

8) Troubleshooting checklist

• Output is vague → tighten Goal & Acceptance bullets (Section 1). (xAI Docs)

• Hallucinated paths/APIs → paste the actual file excerpts and list valid function names. (xAI Docs)

• Slow/expensive loops → stabilize prompt prefix and keep context labeled; leverage cached input rates. (xAI Docs)

• Tool not called → nudge in the system: “Prefer tool calls when validation or execution reduces risk.” (xAI Docs)

• Need to inspect thinking → enable streaming and read reasoning_content. (xAI Docs)

9) One-screen starter kit (copy this into your project)

# SYSTEM
Senior engineer with tool access. Implement changes safely with minimal diffs.
Prefer native tool calls. Always show: plan → diff → tests → risks/rollback.

# USER
## Task
<plain-English request>

## Requirements
<bullets with must-haves & constraints>

## Context
<only the relevant file excerpts, each in its own section with a clear name>

## Acceptance
<tests, commands, perf target, doc snippet>

Sources

xAI’s official Prompt Engineering for Grok Code Fast 1 (model roles, examples, iteration, agentic vs one-shot, reasoning traces, native tool calling, structured context, caching). (xAI Docs)
xAI Function Calling guide + Cookbook examples. (xAI Docs)
xAI Grok Code Fast 1 model page (context window, pricing incl. cached tokens). (xAI Docs)
(General ops) Retry/backoff deployment guidance and agent caution patterns. (Oracle Docs, The Wall Street Journal)

If you want, I can tailor this into a repo-ready .md with your codebase’s conventions and a few prewired tool schemas.