26 Grok Prompts for Coding (2026)

You are a senior [LANGUAGE] engineer. I have a bug in a [FRAMEWORK] app.

Here is the stack trace:
[PASTE STACK TRACE]

Here is the relevant code:
[PASTE CODE]

Do this: (1) state the single most likely root cause in one sentence, (2) explain the chain of events that leads to the error, (3) give the fix as a unified diff, (4) list any assumptions you made. Do not rewrite unrelated code.

Act as a debugging partner for [LANGUAGE]/[FRAMEWORK]. I'm pasting an entire file because the bug may not be where I think it is.

Expected behavior: [WHAT SHOULD HAPPEN]
Actual behavior: [WHAT HAPPENS INSTEAD]

[PASTE FULL FILE]

Read the whole file, find the defect, and reply with: the exact line(s) at fault, a one-paragraph explanation, and the corrected full file. Flag any other bugs you spot along the way.

Use Think mode. This bug in my [LANGUAGE] [FRAMEWORK] code happens roughly [FREQUENCY] and I can't reproduce it reliably.

Symptoms: [DESCRIBE]
Environment: [OS / RUNTIME / VERSIONS]
Code: [PASTE CODE]

Reason step by step about race conditions, timing, uninitialized state, and external dependencies. Give me: the most probable trigger, a minimal way to reproduce it deterministically, and the fix as a diff.

I inherited this [LANGUAGE] code and need to change it safely.

[PASTE CODE]

Explain what it does in plain English, function by function. Then map the data flow: inputs, transformations, outputs, and side effects. Finally, list the three riskiest places to modify and why. Keep it under 400 words.

My CI pipeline is red. Here is the failing job log and the config.

Log:
[PASTE LOG]

Config ([TOOL, e.g. GitHub Actions]):
[PASTE CONFIG]

Identify the exact failure, distinguish a real code failure from a flaky or environment issue, and give me the corrected config or command. Show only the changed lines as a diff and explain each change in one line.

Refactor this [LANGUAGE] function for readability without changing its behavior or public signature.

[PASTE FUNCTION]

Constraints: no new dependencies, keep the same inputs and outputs, preserve error handling. Return the refactored function, then a short bullet list explaining each change and why it improves the code.

These [LANGUAGE] files contain duplicated logic. I'm pasting all of them so you can see the full picture.

[PASTE FILE 1 WITH PATH]
[PASTE FILE 2 WITH PATH]
[PASTE FILE 3 WITH PATH]

Identify the shared logic, propose a single reusable [function/module/class], and show how each call site changes. Deliver: the new shared unit as a full file, plus a diff for each call site. Keep behavior identical.

Migrate this [LANGUAGE] code from [OLD LIBRARY/VERSION] to [NEW LIBRARY/VERSION].

[PASTE CODE]

Use DeepSearch to confirm the current [NEW LIBRARY] API rather than guessing, and cite the doc pages you relied on. Return the migrated code as a full file plus a checklist of behavioral differences and anything I must test manually.

This [LANGUAGE] function is too complex and hard to test.

[PASTE FUNCTION]

Reduce its branching and nesting by using guard clauses, early returns, and small helpers. Keep the exact same behavior for all inputs including edge cases. Return the rewritten code and state the before/after nesting depth and number of branches.

Add complete type annotations to this [LANGUAGE] code targeting [TYPE CHECKER, e.g. mypy / TypeScript strict].

[PASTE CODE]

Infer types from usage, add them without changing runtime behavior, and introduce explicit types or interfaces where an "any" would otherwise leak. Return the typed full file and list any spots where the types revealed a latent bug.

You are a senior [LANGUAGE]/[FRAMEWORK] engineer. Build this feature.

Requirement: [DESCRIBE THE FEATURE AND ITS INPUTS/OUTPUTS]
Existing context: [PASTE RELEVANT CODE / INTERFACES]
Constraints: [performance, style guide, no new deps, etc.]

Deliver the implementation as complete files with paths, brief inline comments only where non-obvious, and a short list of the assumptions and trade-offs you made. Do not add features I didn't ask for.

Write a [HTTP METHOD] [PATH] endpoint in [FRAMEWORK] ([LANGUAGE]).

It should: [BEHAVIOR]. Validate input as [RULES], return [SUCCESS SHAPE] on success and proper status codes on error. Match the style of this existing handler:
[PASTE EXAMPLE HANDLER]

Return the handler, request/response types, validation, and error handling as one file. Add a short note on which errors map to which status codes.

Write a command-line tool in [LANGUAGE] that [DOES WHAT].

Flags/arguments: [LIST THEM]
Behavior: [DESCRIBE, INCLUDING FAILURE CASES]

Use [CLI LIBRARY if any], handle bad input gracefully, and print helpful errors. Return the full source, a usage example, and the exact command to install and run it.

Use Think mode. Design [SYSTEM/SERVICE] before I write any code.

Requirements: [FUNCTIONAL AND NON-FUNCTIONAL, e.g. throughput, latency, data volume]
Constraints: [stack, cloud, budget, team size]

Propose an architecture with components and data flow, name the key trade-offs, call out failure modes and how to handle them, and suggest a phased build order. Keep it concrete and tied to my constraints, not generic best practices.

Convert this pseudocode into idiomatic, production-ready [LANGUAGE] using [FRAMEWORK/STYLE GUIDE].

[PASTE PSEUDOCODE]

Add input validation, error handling, and clear names. Keep the logic faithful to the pseudocode. Return the full implementation plus a one-line note on anything in the pseudocode that was ambiguous and how you resolved it.

Write thorough unit tests for this [LANGUAGE] code using [TEST FRAMEWORK].

[PASTE CODE]

Cover the happy path, boundary values, and failure cases. Use clear test names that describe the behavior, mock external dependencies, and avoid testing implementation details. Return the full test file and list any behavior you could not test and why.

Here is a [LANGUAGE] function and its existing tests.

Function: [PASTE]
Tests: [PASTE]

Find the untested edge cases: empty inputs, nulls, extreme values, unicode, concurrency, and error paths. Add only the missing tests using [TEST FRAMEWORK], each with a comment saying which gap it closes. Do not duplicate existing coverage.

Write an integration test in [LANGUAGE]/[TEST FRAMEWORK] for this flow: [DESCRIBE THE FLOW, e.g. create user then fetch profile].

Relevant code and interfaces:
[PASTE]

Set up and tear down test data, hit the real [DB / HTTP layer] where practical, and assert on observable outcomes rather than internals. Return the full test plus setup instructions.

Review this pull request as a strict but constructive senior [LANGUAGE] reviewer.

Diff:
[PASTE DIFF]

Group findings as Blocking, Should-fix, and Nit. For each, cite the file and line, explain the risk, and suggest a concrete fix. Cover correctness, edge cases, readability, and tests. End with a one-line verdict: approve, approve-with-changes, or request-changes.

Audit this [LANGUAGE] code for security issues.

[PASTE CODE]

Check for injection, unsafe deserialization, missing authz/authn, secrets in code, unsafe input handling, and dependency risks. For each issue give the severity, the exploit scenario in one sentence, and the fix as a diff. If you find nothing, say so explicitly rather than inventing issues.

Analyze this [LANGUAGE] code for performance problems.

[PASTE CODE]
Context: [DATA SIZES, HOT PATH, LATENCY TARGET]

Identify the real bottlenecks (algorithmic complexity, N+1 queries, unnecessary allocations, blocking I/O). Rank them by impact, and for the top issues give the optimized code plus the expected complexity or cost change. Ignore micro-optimizations that don't matter here.

Use Think mode. Review this concurrent [LANGUAGE] code for race conditions, deadlocks, and shared-state bugs.

[PASTE CODE]

Trace which state is shared across [threads/goroutines/async tasks] and how it's synchronized. List each hazard with the interleaving that triggers it, then give a safe fix. Return the corrected code and note any assumptions about the runtime's memory model.

Write a [DIALECT, e.g. PostgreSQL] query that [WHAT YOU NEED].

Schema:
[PASTE TABLE DEFINITIONS]
Sample rows (optional):
[PASTE]

Return the query, explain what each clause does, and suggest the indexes that would make it fast. If a simpler or safer query exists, show that too. Assume [ROW COUNTS] when reasoning about performance.

Write a regex for [FLAVOR, e.g. JavaScript / PCRE] that matches [WHAT] and rejects [WHAT NOT].

Should match:
[PASTE EXAMPLES]
Should NOT match:
[PASTE EXAMPLES]

Return the pattern, a plain-English breakdown of each part, and a note on catastrophic backtracking risk. Verify it against every example above and show the pass/fail for each.

Write a production Dockerfile and a [CI TOOL, e.g. GitHub Actions] pipeline for a [LANGUAGE]/[FRAMEWORK] app.

Details: [BUILD STEPS, RUNTIME, PORT, ENV VARS]

Use a multi-stage build for a small final image, run as a non-root user, and pin versions. The pipeline should lint, test, build, and push on tag. Return both files with comments, and list the security and size trade-offs you made.

I'm hitting an error on [OS / SHELL / TOOL, with versions].

Command I ran:
[PASTE COMMAND]
Output/error:
[PASTE OUTPUT]
What I expected: [DESCRIBE]

Explain what the error actually means, give the exact corrected command, and warn me about any destructive side effects before I run it. If more than one fix exists, rank them from safest to riskiest.