Rol: Je bent een senior {LANGUAGE} engineer die {COMPONENT_TYPE} bouwt.
Doel: Implementeer {FUNCTION_NAME} die {FUNCTION_PURPOSE}.
Constraints:
- Volg {STYLE_GUIDE} (naming, docs, error handling).
- Time complexity target: {BIG_O}. Memory constraints: {LIMITS}.
- Inclusief docstring en inline comments voor niet-obvious logic.
- Vermijd external deps tenzij gerechtvaardigd; indien toegevoegd, uitleggen.
Inputs:
- Interfaces/Types: {TYPES}
- Edge cases: {EDGE_CASES}
- Example inputs/outputs: {EXAMPLES}
Deliverables:
1) Final code block only.
2) Brief rationale (bulleted) after the code.

Rol: Je bent een senior Python engineer die een data cleaning utility bouwt.
Doel: Implementeer `normalize_names` die user names standaardiseert.
Constraints:
- Volg PEP8; raise ValueError on invalid types.
- O(n) time; treat whitespace and accents; keep memory linear.
- Docstring + comments.
Inputs:
- Types: List[str] of Iterable[str]
- Edge cases: nulls, multiple spaces, accent marks, hyphenated last names
- Examples: [" José Álvarez ", "ANNA-lou "] → ["jose alvarez", "anna-lou"]
Deliverables:
1) Final code block only.
2) Brief rationale.

Rol: Senior {LANGUAGE} refactoring expert.
Task: Refactor de provided code voor {GOAL}: {READABILITY|PERFORMANCE|SAFETY}.
Rules:
- Preserve public API and behavior.
- Add type hints and docstrings where missing.
- Extract pure functions for testability.
- Replace magic numbers; enforce {STYLE_GUIDE}.
- Provide before/after complexity notes.
Input code:
```{LANGUAGE}
{SOURCE}

### 3) Test Generation Template (Unit + Property Tests)
**Wanneer te gebruiken**: Increase coverage fast.

### 4) Code Review Template (Automated Reviewer Mode)
**Wanneer te gebruiken**: Fast, consistent reviews before human approval.

{UNIFIED_DIFF}

### 5) Debugging Template (Minimal Repro → Root Cause)
**Wanneer te gebruiken**: Find and fix bugs, create repros.

---
## Example: From Ticket to PR With Grok 4 Fast
Let’s walk a realistic scenario: a product ticket requests “search-as-you-type with debounced API calls and optimistic UI.”
1) **Draft the hook**

2) **Ask for tests**

3) **Run a review pass**

4) **Refine**

Outcome: you’ll have production-ready code plus tests, and the AI will have documented its reasoning so a teammate can follow along.
---
## Prompt Patterns That Level Up Output Quality
- **Role + Goal + Constraints + Inputs + Deliverables**: This structure gives Grok 4 Fast everything it needs to stay on rails.
- **Edge-Case Enumeration**: Always list tricky cases. The model will bake them into tests and guards.
- **Complexity Targets**: Asking for O(n) or memory limits nudges better algorithms.
- **API Contracts**: Paste types/interfaces early; the model will align to them.
- **Output Contracts**: Request final code first, then rationale. This keeps responses clean for copy/paste.
---
## Style Guides and Consistency: Make It Team-Ready
If you want consistent output across a team, standardize:
- **Language style guides**: PEP8, Effective Go, Airbnb JS, Rust API Guidelines.
- **Error conventions**: return vs throw, error codes, retry semantics.
- **Testing norms**: naming, fixture directories, coverage thresholds.
- **Security defaults**: input validation, escaping, secrets handling.
Include these as constants in your templates so Grok 4 Fast internalizes them every time.
---
## Security-First Prompts for Safe Code
Add these security clauses to your templates:
- **Input validation**: “Validate and sanitize all untrusted input.”
- **Secrets hygiene**: “No secrets in code. Read from env and document required variables.”
- **Dependency scrutiny**: “Explain and justify any new dependency; prefer standard library.”
- **Serialization safety**: “Use safe parsers; avoid eval/Function/unsafe deserialization.”
- **AuthZ checks**: “Enforce authorization on sensitive routes; add tests for bypass attempts.”
---
## Performance Prompts: Avoid the Usual Footguns
- “Minimize allocations; reuse buffers when large payloads.”
- “Avoid N+1 queries; batch or prefetch.”
- “Use streaming/iterators for big data.”
- “Memoize pure functions; profile hotspots.”
- “Add benchmarks and explain trade-offs.”
---
## Review Checklists You Can Paste Into PRs
Include a short checklist so every review is consistent:
- API compatibility confirmed
- Null/undefined and empty collection handling
- Resource cleanup (files, sockets, subscriptions)
- Concurrency guards (locks, atomics, idempotency)
- Logging levels appropriate; no sensitive data
- Tests updated; migrations documented
---
## Team Workflow: Make Prompt Templates a Shared Asset
- **Centralize templates** in your repo (e.g., `/.prompts` directory).
- **Parameterize** variables like `{LANGUAGE}`, `{STYLE_GUIDE}`, `{BIG_O}` using snippets or editor macros.
- **Version** your prompt templates and review them like code.
- **Create playbooks** for feature drafting, refactoring, test writing, and release checks.
By the way, if your team prefers a side-by-side coding copilot that lives in the browser and inside docs, it’s worth noting that [Sider.ai](https://sider.ai/) can help you store and reuse prompt templates, run code reviews on diffs, and keep context across tabs. It’s a convenient way to operationalize these Grok 4 Fast prompts across your org without copy/paste fatigue.
---
## Copy-Paste Library: Ready-to-Use Prompts
### TypeScript API Handler (Node/Express)

### Python Data Pipeline Step

### Go Concurrency Guard

### React Accessible Component

---
## Hoe te Itereren met Grok 4 Fast (Snelle Feedback Loop)
1) **Begin klein**: Vraag om één functie, niet de hele service.
2) **Beperk outputs**: “Eén codeblok, dan bullets.”
3) **Eis tests**: Elke functie krijgt tests in dezelfde doorgang.
4) **Leg beslissingen vast**: “Leg afwegingen uit. Vraag om verduidelijking indien onzeker.”
5) **Ratcheting**: Verbeter in lagen—eerst correctheid, dan prestaties, dan leesbaarheid.
---
## Succes Meten: Hebben de Templates Geholpen?
Volg eenvoudige metrics:
- PR-cyclustijd (aangemaakt → samengevoegd)
- Review rework rate (aangevraagde wijzigingen per PR)
- Test coverage delta per functie
- Productie-incidenten gerelateerd aan code die is beoordeeld door AI
Als de cijfers de goede kant op gaan, verdubbel dan. Zo niet, stem dan uw templates af en voeg meer context toe (types, logs, diffs).
---
## Veelvoorkomende Fouten om te Vermijden
- Te brede prompts zoals “bouw de backend”. Splits op in eenheden.
- Edge cases vergeten. Vermeld ze altijd.
- Library sprawl toestaan. Vraag om rechtvaardiging.
- Tests overslaan “voor later”. Bak ze in de prompt.
- Vage reviews accepteren. Eis checklists en severity levels.
---
## Quick-Start Checklist
- Maak een `/prompts` folder in uw repo.
- Sla de drafting-, review- en testingtemplates op.
- Parameteriseer gemeenschappelijke velden met snippet variables.
- Pilot op één functie deze week; meet outcomes.
- Iterate op basis van reviewer feedback en incidenten.
---
## Laatste Gedachte
Grok 4 Fast is uitstekend in het snel produceren van code—maar de echte kracht komt van goed gestructureerde prompt templates die uw standaarden encoderen. Behandel prompts als infrastructuur. Version ze. Review ze. En laat Grok 4 Fast de boilerplate afhandelen, zodat uw team zich kan concentreren op architectuur en product.
Volgende stap: kies een template hierboven, plak deze in uw editor, wissel uw context in en ship vandaag nog een PR.
### FAQ
Q1:Hoe gebruik ik Grok 4 Fast voor code drafting met consistente stijl?
Gebruik een gestructureerde prompt template die role, goal, constraints en style guide instelt. Voeg complexity targets, edge cases en deliverables toe, zodat Grok 4 Fast consistente, production-ready code output.
Q2:Kan Grok 4 Fast betrouwbare code reviews uitvoeren met prompt templates?
Ja. Geef een diff, de standaarden van uw team en een checklist voor security, prestaties en API-compatibiliteit. Vraag om severity-ranked bevindingen en minimale patch suggestions.
Q3:Wat is de beste manier om tests te genereren met Grok 4 Fast?
Gebruik een test generation template die framework, coverage goals en edge cases specificeert. Vraag zowel unit- als property-based tests plus een kort coverage plan.
Q4:Hoe voorkom ik onveilige code van AI-outputs?
Voeg security clauses toe aan uw prompts: input validation, secrets hygiene, dependency justification en safe serialization. Vereis expliciete notes over security trade-offs.
Q5:Hoe versnellen prompt templates PR-cycli met Grok 4 Fast?
Templates verminderen ambiguity, standardiseren outputs en front-load tests en reviews. Dat verkort back-and-forth, verlaagt rework en helpt u sneller te mergen.