Code and Technical Tasks

Grok for Developers

xAI offers a model specifically optimized for code: grok-build-0.1 (Grok Build). This lightweight model is designed for pair programming in code editors. It is significantly faster and less expensive than general-purpose models. However, a model like Grok 4.5 remains relevant for complex debugging and architecture.

Whether you use Grok to generate code, debug, document, or review code, the prompting principles covered in this course apply with a few specifics.

Code Generation

The Minimal Prompt (Avoid This)

Create a food tracker

The Effective Prompt

Create a food tracker in Python with Flask.

Features:
- Log a food item with quantity
- Automatic calculation of calories and macronutrients
- Display daily calorie breakdown by nutrient
- High-level overview and trends

Technical constraints:
- SQLite database
- REST API with documented endpoints
- No frontend (API only)
- Unit tests with pytest
- Error handling with appropriate HTTP codes

xAI documentation emphasizes this point: specify file paths, project structure, and dependencies. Exclude irrelevant information.

Debugging

Debugging is a use case where context is particularly important. Provide the model with all the information necessary to reproduce the problem.

Structured Debugging Prompt

I have an error in my Node.js/Express application.

Relevant code:
```javascript
app.get('/api/users/:id', async (req, res) => {
  const user = await db.query('SELECT * FROM users WHERE id = $1', [req.params.id]);
  res.json(user.rows[0]);
});
```

Error:
TypeError: Cannot read properties of undefined (reading 'rows')

Context:
- Node.js 20, Express 4.18, pg 8.11
- PostgreSQL 15 locally
- The 'users' table exists and contains data
- The error occurs only for certain IDs

My error codes are defined in src/errors.ts.
The DB connection file is src/db.ts.

Identify the probable cause and propose a fix.

Error with Stack Trace

Fix this error. Here is the full stack trace:

[paste the stack trace]

Relevant source file:
[paste the code]

Configuration:
- Python 3.12, Django 5.0
- PostgreSQL database
- Environment: Docker production

Explain the root cause and propose the fix.

Documentation

Function Documentation

Document this Python function using Google docstring conventions:

def calculate_weighted_score(items, weights=None, normalize=True):
    if weights is None:
        weights = [1.0] * len(items)
    if len(items) != len(weights):
        raise ValueError("Mismatch")
    total = sum(i * w for i, w in zip(items, weights))
    if normalize:
        total /= sum(weights)
    return round(total, 4)

Include:
- Function description
- Args with types and descriptions
- Returns with type and description
- Raises with conditions
- A usage example (doctest)

API Documentation

Generate OpenAPI (Swagger) documentation for this endpoint:

Endpoint: POST /api/v2/invoices
Authentication: Bearer token
Body: JSON with client_id (int, required), items (array of objects with description, quantity, unit_price), due_date (ISO 8601, optional)
Responses: 201 (created), 400 (validation), 401 (unauthenticated), 500 (server error)

Format: YAML OpenAPI 3.0

Code Review

Review the code in this pull request.

Code:
[paste the code]

Evaluation criteria:
1. Potential bugs or unhandled edge cases
2. Performance (algorithmic complexity, N+1 queries)
3. Security (injections, data leaks)
4. Readability and maintainability
5. Adherence to PEP 8 conventions

For each issue found:
- Line(s) concerned
- Severity: critical / high / low / suggestion
- Explanation of the problem
- Proposed corrected code

Model Selection for Code

xAI documentation recommends:

• grok-build-0.1: Quick work, implementation, code search, routine refactoring
• Grok 4.5: Complex debugging, architecture, deep conceptual problems

For code agents using tool-calling, prefer the native tool-calling of grok-build-0.1 over XML outputs, which can degrade performance.

Cache Optimization

For sequential interactions (typical of pair programming), Grok’s cache significantly speeds up responses. The conversation prefix remains identical between requests, allowing retrieval from the cache.

Important tip: Avoid modifying the prompt history between requests. Any modification breaks the cache and slows down inference.

Hands-On Practice

Take a real bug from your code. Write a structured debugging prompt including the code, the error, the technical context, and related files. Compare the quality of the response with a minimal prompt (“fix this bug: [code]”).

Key Takeaways

• Always specify the complete technical context: language, framework, versions, project structure
• grok-build-0.1 is optimized for code: faster and cheaper than general-purpose models
• For debugging, provide the code, the full error, and the execution context
• Use native tool-calling rather than XML outputs for code agents
• Avoid modifying the prompt history to maintain cache and speed
• Grok 4.5 remains the best choice for complex debugging and architecture decisions