Grok for Code Generation: Prompts & Debugging Patterns

Write a [language] function that meets this specification:

Function: [name]
Purpose: [what it does]
Inputs:
  - [param1]: [type] — [description]
  - [param2]: [type] — [description]
Returns: [type] — [description]
Constraints:
  - [constraint 1]
  - [constraint 2]
Edge cases to handle:
  - [edge case 1]
  - [edge case 2]

Use the CURRENT version of [library/framework]. Check the latest
documentation if you're unsure about the API.

Include:
- Type annotations
- Error handling for the specified edge cases
- A docstring explaining usage
- 3 unit test examples

Generate a [component/function/module] using [framework] version [X.Y].

Requirements:
[detailed requirements]

Important:
- Verify this code works with [framework] v[X.Y] — check the current
  documentation for any API changes in this version
- If v[X.Y] changed the API from earlier versions, use the NEW API
  and note the change
- Do not use any deprecated methods or patterns

I need to build [describe the system/feature].

Before writing any code:
1. Outline the architecture — components, data flow, key interfaces
2. Identify potential design tradeoffs (e.g., performance vs. simplicity)
3. Recommend the approach you'd take and justify it
4. List any external dependencies and their current versions

Then implement the recommended approach. Structure the code into
logical files/modules and explain the purpose of each.

I have a bug in the following code:

```[language]
[paste code]

### Code Review Pattern

[paste code]

## Leveraging Real-Time Docs Access

This is Grok's coding superpower. When you explicitly ask Grok to check current documentation, you get code that works against the latest API versions.

### Current-Docs Prompt Pattern

### Migration Pattern

When updating code from an older library version:

[paste code]

<Note type="warning">
**Verify generated code before deploying.** Grok's real-time docs access improves API accuracy, but generated code still needs testing. Real-time access helps with API signatures and method names — it doesn't guarantee logical correctness or proper error handling for your specific use case.
</Note>

## Prompt Examples

<PromptCard
  prompt={`Write a Python function that sends a multipart email with attachments
using the current Gmail API.

Specification:
- Function: send_email_with_attachments
- Inputs:
  - to: str (recipient email)
  - subject: str
  - body_html: str (HTML body content)
  - attachments: list[str] (file paths to attach)
  - credentials_path: str (path to OAuth2 credentials JSON)
- Returns: dict with message_id and thread_id
- Error handling: raise clear exceptions for auth failures, file not found,
  and API errors

IMPORTANT: Check the CURRENT Google Gmail API documentation. The
authentication and message construction APIs have changed multiple times.
Use the latest recommended approach, not deprecated oauth2client patterns.

Include:
- Full import statements
- Type hints
- A usage example in the docstring
- Note which google-api-python-client version this targets`}
  tags={["Code Generation", "Python", "API Integration"]}
/>

---

<PromptCard
  prompt={`Debug this React component that's causing an infinite re-render loop:

\`\`\`tsx
import { useState, useEffect } from 'react';

function UserProfile({ userId }: { userId: string }) {
  const [user, setUser] = useState(null);
  const [preferences, setPreferences] = useState({});

  useEffect(() => {
    fetch(\`/api/users/\${userId}\`)
      .then(res => res.json())
      .then(data => {
        setUser(data);
        setPreferences(data.preferences || {});
      });
  }, [userId, preferences]);

  return (
    <div>
      <h1>{user?.name}</h1>
      <pre>{JSON.stringify(preferences, null, 2)}</pre>
    </div>
  );
}
\`\`\`

Error: Component re-renders infinitely, causing browser tab to freeze.

Step by step:
1. Identify the root cause of the infinite loop
2. Explain WHY this causes infinite re-renders (trace the dependency chain)
3. Provide the fixed code
4. Check if this pattern has any known React 19 / React Compiler implications
5. Suggest a lint rule or pattern to prevent this class of bugs`}
  tags={["Debugging", "React", "TypeScript"]}
/>

---

<PromptCard
  prompt={`I need to build a rate limiter middleware for a Go HTTP server.

Requirements:
- Token bucket algorithm
- Per-IP rate limiting
- Configurable: requests per second and burst size
- Thread-safe (handles concurrent requests)
- Returns 429 Too Many Requests with Retry-After header when limit exceeded
- Cleanup: automatically removes entries for IPs that haven't been seen in 10 minutes

Architecture first:
1. Outline the data structures and concurrency approach
2. Identify the right Go stdlib packages (check current Go docs for
   the latest net/http middleware patterns)
3. Discuss sync.Map vs mutex-protected map for this use case

Then implement:
- The rate limiter struct and methods
- The HTTP middleware function
- A usage example with http.NewServeMux
- A test that verifies rate limiting behavior

Target: Go 1.23+ — use current standard library patterns.`}
  tags={["Code Generation", "Go", "System Design"]}
/>

## Related Pages

- **[Grok 4.5 Prompt Guide](/prompts/grok/models/grok45)** — System prompt patterns and reasoning strategies for Grok 4.5, including the chain-of-thought patterns useful for complex code architecture
- **[Agent Framework](/prompts/grok/capabilities/agent-framework)** — Build automated coding agents that use Grok's tool calling for code analysis, testing, and deployment workflows