Portuguese to English Prompt Translation

Overview

Brazilian Portuguese prompts are colloquial and context-heavy; English prompts need explicit requirements. This skill bridges the gap by clarifying vague terms, preserving urgency signals, handling idioms, and structuring requests.

Core principle: Colloquial Portuguese assumes shared context. English for Claude requires clear scope, constraints, and success criteria.

YOUR ONLY OUTPUT IS A STRUCTURED ENGLISH PROMPT. Do NOT implement, scaffold, explore files, or run any code. Do NOT attempt to solve the problem described. Stop after delivering the prompt inside a code block and wait for user confirmation.

When to Use

Translate when:

• User writes in Brazilian Portuguese and needs an English prompt for Claude Code
• Message contains colloquialisms ("ta bagunça", "pra ontem", "spaghetti")
• Requirements are implicit or context-dependent
• Urgency or emotion needs preservation in English

Do NOT use for:

• Already-clear English prompts
• Translation of documentation (use professional translation services)
• Non-Brazilian Portuguese (different idioms)

Allowed Context Gathering

Before translating, you MAY perform 1–2 targeted lookups to fill gaps that would make the prompt ambiguous or incomplete. Acceptable sources:

• claude-mem

  or project memory — to check stack, naming conventions, or existing file structure

• CLAUDE.md

  — to check project-level constraints or patterns

Only look up what's directly needed to clarify the prompt. Do not browse the codebase, run commands, or explore files broadly.

Examples of acceptable lookups:

• "What's the state management solution in use?" (to clarify how to phrase persistence requirement)
• "Does this project already have a Tag model?" (to avoid duplicating in the prompt)

If no lookup is needed, skip this step entirely and translate directly.

Pattern: Translate → Clarify → Structure

1. Identify Intent (Extract Core Ask)

Extract what the user actually wants, not just the words:

• "ta lento" = performance problem; ask: render time? bundle? memory?
• "pra ontem" = high urgency; mark explicitly
• "cores customizáveis" = clarify: user-editable at runtime? config-only?

2. Preserve Urgency & Emotion

Map colloquial signals to explicit English:

• "pra ontem" (for yesterday) → urgency flag: "ASAP" or deadline
• "ta uma bagunça" (is a mess) → clarify what's messy (structure, naming, performance)
• "preciso disso ontem" → deadline or blocking context

3. Clarify Ambiguous Terms

Transform vague Portuguese into specific English:

Portuguese	Vague	→ Clarified English
"otimizar"	slower than what?	"improve render performance" OR "reduce bundle size" OR "optimize time complexity"
"cores customizáveis"	editable how?	"user picks from 12 swatches" OR "admin configures in settings"
"sem backend"	scope?	"no API calls, all data in localStorage"
"refatora"	reduce what?	"extract functions", "reduce nesting", "improve naming", "split by concern"

4. Structure as: Purpose → Requirements → Constraints → Expected Deliverable → Edge Cases

Example transformation:

Portuguese:

me ajude a implementar tags nas tarefas, precisa funcionar offline,
usar localStorage, cores customizáveis, máximo 12 cores, pra ontem

English (Structured):

Implement a tag system for tasks with:

**Purpose:** Categorize tasks with persistent tags across offline/online states

**Requirements:**
- Create Tag interface with id, name, color
- Assign tags to tasks (one tag max or multiple?)
- Color picker: 12 predefined swatches
- All data persists to localStorage
- Offline-first: changes sync when connection restored

**Constraints:**
- Max 12 colors per tag system
- localStorage as data source (no API calls)
- [URGENT] Needed ASAP

**Edge Cases:**
- What happens when colors conflict with theme?
- Can users delete tags if tasks reference them?
- Export/import tag config?

**Expected Deliverable:** Tag interface, storage adapter, UI component

After writing this prompt, your job is done. Output it in a code block and stop.

---

Quick Reference

Checklist before finalizing translation:

• Identified vague terms and asked clarifying questions
• Extracted core intent (not just literal words)
• Marked urgency explicitly (deadline, blocking context)
• Resolved ambiguous Portuguese expressions
• Structured as Purpose → Requirements → Constraints → Expected Deliverable → Edge Cases
• Noted assumptions/ambiguities that user should confirm
• Did NOT implement, run, or scaffold anything

Common Mistakes

Literal word translation

• "ta uma bagunça refatora" → "it's a mess refactor" (unclear)
• Better: "refactor this [component/function] — code is deeply nested and hard to follow"

Losing urgency signals

• "pra ontem" → simply omit timeline (loses context)
• Better: Explicitly mark: "[URGENT: Needed by EOD]"

Not clarifying ambiguity**

• "cores customizáveis" → "customizable colors" (still vague)
• Better: Ask: "Are these user-editable at runtime or config-only?"

Skipping scope clarification

• "otimizar isso" → "optimize it" (optimize what metric?)
• Better: "Optimize render performance for [specific component] — currently takes X ms, should be <Y ms"

Starting to implement after translating

• Agent reads the prompt it just generated and starts building
• Better: Output the prompt in a code block, then stop and wait

Real-World Example

Input (Portuguese):

me ajude a criar um componente react que mostre uma lista de tarefas
com drag-and-drop, precisa funcionar no mobile também, e a persistência
tem que ser no localStorage, pra ontem

Output (English):

Create a React task list component with:

**Purpose:** Display tasks with reorderable drag-and-drop interface, mobile + desktop compatible

**Requirements:**
- Render task list with drag-to-reorder
- Touch-friendly on mobile (minimum 44px tap targets)
- Persist reorder changes to localStorage
- Preserve existing task data structure

**Constraints:**
- Mobile-first: touch drag-and-drop must work on iOS/Android
- localStorage only (no API calls)
- Maintain accessibility (keyboard reorder fallback)
- [URGENT] Needed ASAP

**Edge Cases:**
- What if task list is empty?
- How to handle interrupted drag (user cancels)?
- Does reorder trigger animation?

**Expected Deliverable:** Component with drag-drop hooks, localStorage sync, test coverage

✅ Prompt delivered. Task complete — do not proceed to implementation.

---

Common Edge Cases

Context carryover ("continue from previous"): If Portuguese mentions prior work, ask for explicit reference:

Portuguese: "continua onde parou, coloca tags nisso"
Ask: "Continue from which previous conversation/task?" → Get issue ID or context

Mixed Portuguese-English prompts: When user switches languages mid-request, treat as single context:

Portuguese: "implementar esse component"
English: "with hooks and responsive design"
→ Consolidate into one structured prompt (don't translate English parts)

Implied deadline vs. urgency: "Pra ontem" / "ASAP" needs actual deadline context:

[URGENT: Needed ASAP] BUT ask: "Blocking a release? Hard deadline? Nice-to-have?"

CRITICAL: Don't accept vague answers. Demand specificity:
- "Hard deadline" → REQUIRES: "by 5 PM today" OR "before demo Thursday"
- "Blocking release" → REQUIRES: "blocks prod deploy?" (yes/no + date)
- "Nice-to-have" → REQUIRES: "quick win (2 hours)" OR "requires refactor (sprint)"

Vague urgency (just "it's urgent") = user hasn't made execution decision yet.
Push back until you know: hack/workaround OR production-grade solution?

Domain-specific terminology: "Otimizar" varies by context (render time vs. bundle vs. time complexity):

Portuguese: "otimizar a lista de tarefas"
Clarify by context: React component → likely render performance
Database query → likely time complexity
UI response → likely interaction latency

Note on Ambiguities

If Portuguese request has gaps (common—context is assumed), note them at the end of your English translation:

Assumptions/Ambiguities:
- "cores customizáveis" — assuming user-editable at runtime; confirm if config-only
- "otimizar" — unclear metric; assuming render performance, not bundle size
- "pra ontem" — translating as "ASAP"; clarify actual deadline if different

This helps the prompt recipient clarify with the user before implementing.