SpyBara
Go Premium

prompt-library.md 2026-10-01 23:59 UTC to 2026-10-02 08:03 UTC

This page contains 324 additions and 101 deletions.

2026
Fri 2 09:02

Biblioteca de prompts

Prompts para copiar y pegar en Claude Code, etiquetados por tarea y rol.

export const PromptLibrary = ({text = {}, labels = {}, tagLabels = {}, phaseLabels = {}, sourceLabels = {}, catLabels = {}}) => { const RAW = useMemo(() => [{ id: 'get-oriented-in-a', sdlc: 'discover', cat: 'Onboard', startN: 1, roles: [], prompt: 'give me an overview of this codebase: architecture, key directories, and how the pieces connect', nextHref: '/en/memory', src: 'workflows' }, { id: 'explain-unfamiliar-code', sdlc: 'discover', cat: 'Understand', roles: [], prompt: 'explain what {path} does and how data flows through it. write it up as {format}', slots: { path: 'src/scheduler/queue.ts', format: 'an HTML page with a diagram, then open it in my browser' }, nextHref: '/en/output-styles', src: 'workflows' }, { id: 'find-where-something-happens', sdlc: 'discover', cat: 'Understand', startN: 2, roles: [], prompt: 'where do we {behavior}?', slots: { behavior: 'validate uploaded file types' }, src: 'workflows' }, { id: 'see-what-depends-on', sdlc: 'discover', cat: 'Understand', roles: [], prompt: 'what would break if I deleted {target}?', slots: { target: 'the retryWithBackoff helper' }, src: 'workflows' }, { id: 'trace-how-code-evolved', sdlc: 'discover', cat: 'Understand', roles: [], prompt: 'look through the commit history of {path} and summarize how it evolved and why', slots: { path: 'internal/auth/session.go' }, src: 'best-practices' }, { id: 'scope-a-change-before', sdlc: 'discover', cat: 'Understand', roles: ['pm', 'design'], prompt: 'which files would I need to touch to {change}?', slots: { change: 'add a dark mode toggle to settings' }, src: 'teams' }, { id: 'ask-the-codebase-a', sdlc: 'discover', cat: 'Understand', roles: ['pm'], prompt: 'I am a {role}. walk me through what happens when a user {action}, from the UI down to the result', slots: { role: 'PM', action: 'clicks Export to PDF' }, nextHref: '/en/output-styles', src: 'teams' }, { id: 'plan-a-multi-file', sdlc: 'design', cat: 'Plan', roles: ['pm', 'design'], prompt: 'plan how to refactor the {target} to {goal}. list the files you would change, but don't edit anything yet', slots: { target: 'payment module', goal: 'support multiple currencies' }, src: 'workflows' }, { id: 'draft-a-spec-by', sdlc: 'design', cat: 'Plan', roles: ['pm'], prompt: 'I want to build {feature}. interview me about implementation, UX, edge cases, and tradeoffs until we have covered everything, then write the spec to SPEC.md', slots: { feature: 'per-workspace rate limits' }, nextHref: '/en/skills', src: 'best-practices' }, { id: 'turn-a-meeting-into', sdlc: 'design', cat: 'Plan', roles: ['pm'], prompt: 'read {input} and write up the action items, then create a {tracker} ticket for each with acceptance criteria', slots: { input: '@meeting-notes.md', tracker: 'Linear' }, needs: 'tracker', nextHref: '/en/skills', src: 'teams' }, { id: 'map-edge-cases-before', sdlc: 'design', cat: 'Plan', roles: ['design', 'pm'], prompt: 'list the error states, empty states, and edge cases for {feature} that the design needs to cover', slots: { feature: 'the file upload flow' }, src: 'teams' }, { id: 'turn-a-mockup-into', sdlc: 'design', cat: 'Prototype', roles: ['design', 'pm', 'marketing'], paste: 'mockup', prompt: 'here is a mockup. build a working prototype I can click through, matching the layout and states shown', src: 'teams' }, { id: 'implement-from-a-screenshot', sdlc: 'design', cat: 'Prototype', roles: ['design'], paste: 'design', needs: 'browser', prompt: 'implement this design, then take a screenshot of the result, compare it to the original, and fix any differences', nextHref: '/en/goal', src: 'best-practices' }, { id: 'follow-an-existing-pattern', sdlc: 'build', cat: 'Implement', roles: [], prompt: 'look at how {example} is implemented to understand the pattern, then build {new} the same way', slots: { example: 'the GitHub webhook handler', new: 'a Stripe webhook handler' }, nextHref: '/en/memory', src: 'best-practices' }, { id: 'generate-docs-for-code', sdlc: 'build', cat: 'Implement', roles: ['docs'], prompt: 'find {scope} without {format} comments and add them, matching the style already used in the file', slots: { scope: 'the public functions in src/auth/', format: 'JSDoc' }, src: 'workflows' }, { id: 'add-a-small-well', sdlc: 'build', cat: 'Implement', roles: [], prompt: 'add a {endpoint} endpoint that returns {payload}', slots: { endpoint: '/health', payload: 'the app version and uptime' }, src: 'workflows' }, { id: 'build-a-small-internal', sdlc: 'build', cat: 'Implement', roles: ['pm', 'design', 'marketing', 'docs'], prompt: 'create a {tool} using HTML, CSS, and vanilla JavaScript, then open it in my browser', slots: { tool: 'drag-and-drop Kanban board with three columns' }, src: 'teams' }, { id: 'work-an-issue-end', sdlc: 'build', cat: 'Implement', roles: [], prompt: 'read issue #{issue}, implement the fix, and run the tests', slots: { issue: '312' }, needs: 'gh', src: 'workflows' }, { id: 'find-and-update-copy', sdlc: 'build', cat: 'Implement', roles: ['design', 'docs', 'marketing'], prompt: 'find every place we say "{copy}" or a close variant, show me each one in context, then update them all to "{new}". leave tests and the changelog alone', slots: { copy: 'Sign up free', new: 'Start free trial' }, src: 'teams' }, { id: 'draft-from-past-examples', sdlc: 'build', cat: 'Implement', roles: ['docs', 'marketing', 'pm'], prompt: 'read the {examples} in {folder} to learn the structure and voice, then draft a new one for {topic}', slots: { examples: 'privacy impact assessments', folder: 'legal/pia/', topic: 'the new analytics integration' }, nextHref: '/en/skills', src: 'legal' }, { id: 'write-tests-run-them', sdlc: 'build', cat: 'Test', startN: 4, roles: [], prompt: 'write tests for {path}, run them, and fix any failures', slots: { path: 'app/parsers/feed.py' }, nextHref: '/en/memory', src: 'workflows' }, { id: 'drive-implementation-from-tests', sdlc: 'build', cat: 'Test', roles: [], prompt: 'write tests for {feature} first, then implement it until they pass', slots: { feature: 'the password reset flow' }, src: 'ebook' }, { id: 'fill-gaps-from-a', sdlc: 'build', cat: 'Test', roles: [], prompt: 'read {report} and add tests for the lowest-covered files until each is above {target}%', slots: { report: 'coverage/coverage-summary.json', target: '80' }, nextHref: '/en/goal', src: 'workflows' }, { id: 'migrate-a-pattern-across', sdlc: 'build', cat: 'Refactor', roles: [], prompt: 'migrate everything from {from} to {to}: identify every place that needs to change, then make the changes', slots: { from: 'the old logging API', to: 'the structured logger' }, src: 'workflows' }, { id: 'port-code-between-languages', sdlc: 'build', cat: 'Refactor', roles: [], prompt: 'port {source} to {target}, keeping the same {keep}', slots: { source: 'this Python module', target: 'Rust', keep: 'public API and test behavior' }, src: 'teams' }, { id: 'optimize-against-a-measurable', sdlc: 'build', cat: 'Refactor', roles: ['data'], prompt: 'optimize {target} to bring {metric} from {current} down to under {goal}', slots: { target: 'the search query', metric: 'p95 latency', current: '2s', goal: '500ms' }, nextHref: '/en/goal', src: 'ebook' }, { id: 'fix-a-precise-visual', sdlc: 'build', cat: 'Refactor', roles: ['design'], prompt: 'the {element} extends {amount} beyond the {container} on {viewport}. fix it.', slots: { element: 'login button', amount: '20px', container: 'card border', viewport: 'mobile' }, nextHref: '/en/desktop#preview-your-app', src: 'ebook' }, { id: 'review-your-changes-before', sdlc: 'build', cat: 'Review', startN: 5, roles: [], prompt: 'review my uncommitted changes and flag anything that looks risky before I commit', nextHref: '/en/commands', src: 'workflows' }, { id: 'review-a-pull-request', sdlc: 'build', cat: 'Review', roles: [], prompt: 'review PR #{pr} and summarize what changed, then list any concerns', slots: { pr: '247' }, needs: 'gh', nextHref: '/en/code-review', src: 'workflows' }, { id: 'review-infrastructure-changes-before', sdlc: 'build', cat: 'Review', roles: ['security', 'ops'], paste: 'plan', prompt: 'here is my Terraform plan output. what is this going to do, and is anything here going to cause problems?', src: 'teams' }, { id: 'run-a-security-review', sdlc: 'build', cat: 'Review', roles: ['security'], prompt: 'use a subagent to review {path} for security issues and report what it finds', slots: { path: 'src/api/' }, nextHref: '/en/sub-agents', src: 'best-practices' }, { id: 'review-content-before-sending', sdlc: 'build', cat: 'Review', roles: ['marketing', 'docs'], prompt: 'review {file} for {concerns} and list anything I should fix before it goes to {reviewer}', slots: { file: 'launch-post.md', concerns: 'unsupported claims, missing attributions, and brand-guideline issues', reviewer: 'legal' }, nextHref: '/en/skills', src: 'legal' }, { id: 'course-correct-a-wrong', sdlc: 'build', cat: 'Steer', roles: [], prompt: 'that is not right: {feedback}. try a different approach', slots: { feedback: 'the function signature needs to stay backward-compatible' }, nextHref: '/en/checkpointing', src: 'best-practices' }, { id: 'narrow-the-scope-of', sdlc: 'build', cat: 'Steer', roles: [], prompt: 'that is too much. keep only the changes to {scope} and undo your other edits', slots: { scope: 'the validation logic in src/forms/' }, src: 'best-practices' }, { id: 'turn-a-correction-into', sdlc: 'build', cat: 'Steer', roles: [], prompt: 'you keep {mistake}. add a rule to CLAUDE.md so this stops happening', slots: { mistake: 'using default exports when this project uses named exports' }, nextHref: '/en/memory', src: 'best-practices' }, { id: 'resolve-merge-conflicts', sdlc: 'ship', cat: 'Git', roles: [], prompt: 'resolve the merge conflicts in this branch and explain what you kept from each side', src: 'workflows' }, { id: 'commit-with-a-generated', sdlc: 'ship', cat: 'Git', roles: [], prompt: 'commit these changes with a message that summarizes what I did', src: 'workflows' }, { id: 'open-a-pull-request', sdlc: 'ship', cat: 'Git', roles: [], prompt: 'find the {tracker} ticket about {topic} and open a PR that implements it', slots: { tracker: 'Linear', topic: 'the login timeout' }, needs: 'tracker', src: 'workflows' }, { id: 'draft-release-notes-from', sdlc: 'ship', cat: 'Release', roles: ['pm', 'docs', 'marketing'], prompt: 'compare {from} to {to} and draft release notes grouped by feature, fix, and breaking change', slots: { from: 'v2.3.0', to: 'v2.4.0' }, nextHref: '/en/skills', src: 'workflows' }, { id: 'write-a-ci-workflow', sdlc: 'ship', cat: 'Release', roles: ['ops'], prompt: 'write a GitHub Actions workflow that {steps} on every push to {branch}', slots: { steps: 'runs the tests and deploys to staging', branch: 'main' }, src: 'workflows' }, { id: 'find-and-fix-a', sdlc: 'operate', cat: 'Debug', startN: 3, roles: [], prompt: 'the {test} test is failing, find out why and fix it', slots: { test: 'UserAuth' }, src: 'workflows' }, { id: 'investigate-a-reported-error', sdlc: 'operate', cat: 'Debug', roles: ['ops'], prompt: 'users are seeing {symptom} on {where}. investigate and tell me what is going on', slots: { symptom: '500 errors', where: '/api/settings' }, nextHref: '/en/web-quickstart#pre-fill-sessions', src: 'workflows' }, { id: 'fix-a-build-error', sdlc: 'operate', cat: 'Debug', roles: ['ops'], paste: 'error', prompt: 'here is a build error. fix the root cause and verify the build succeeds', src: 'best-practices' }, { id: 'investigate-a-production-incident', sdlc: 'operate', cat: 'Incident', roles: ['ops', 'security'], prompt: '{symptom}. check the logs, recent deploys, and config changes, then tell me the most likely cause', slots: { symptom: 'the checkout endpoint started returning 500s an hour ago' }, nextHref: '/en/mcp', src: 'workflows' }, { id: 'diagnose-from-a-console', sdlc: 'operate', cat: 'Incident', roles: ['ops', 'data'], paste: 'screenshot', prompt: 'here is a screenshot of {console}. walk me through why {resource} is failing and give me the exact commands to fix it', slots: { console: 'the GCP Kubernetes dashboard', resource: 'this pod' }, src: 'teams' }, { id: 'query-logs-in-plain', sdlc: 'operate', cat: 'Incident', roles: ['security', 'ops', 'data'], prompt: 'show me all {events} for {scope} over {timeframe}. write the query, run it, and tell me what stands out', slots: { events: 'failed logins', scope: 'the auth service', timeframe: 'the past 24 hours' }, needs: 'db', src: 'cybersecurity' }, { id: 'analyze-a-data-file', sdlc: 'operate', cat: 'Data', roles: ['data', 'pm', 'marketing'], paste: 'csv', prompt: 'read {file}, summarize the key patterns, and write the results to {output}', slots: { file: '@reports/q1-signups.csv', output: 'an HTML page with charts, then open it in my browser' }, nextHref: '/en/mcp', src: 'teams' }, { id: 'generate-variations-from-performance', sdlc: 'operate', cat: 'Data', roles: ['marketing', 'data'], paste: 'csv', prompt: 'read {file}, find the underperforming {items}, and generate {n} new variations that stay under {limit} characters', slots: { file: '@ads-performance.csv', items: 'headlines', n: '20', limit: '90' }, nextHref: '/en/mcp', src: 'teams' }, { id: 'turn-a-recurring-task', sdlc: 'operate', cat: 'Automate', roles: [], prompt: 'create a /{name} skill for this project that {steps}', slots: { name: 'ship', steps: 'runs the linter and tests, then drafts a commit message' }, src: 'workflows' }, { id: 'add-a-hook-for', sdlc: 'operate', cat: 'Automate', roles: [], prompt: 'write a hook that {action} after every {event}', slots: { action: 'runs prettier', event: 'edit to a .ts or .tsx file' }, src: 'best-practices' }, { id: 'connect-a-tool-with', sdlc: 'operate', cat: 'Automate', roles: [], prompt: 'set up the {server} MCP server so you can read my {data} directly', slots: { server: 'Sentry', data: 'error reports' }, src: 'workflows' }, { id: 'capture-what-to-remember', sdlc: 'operate', cat: 'Automate', roles: ['pm', 'docs'], prompt: 'summarize what we did this session and suggest what to add to CLAUDE.md', src: 'teams' }], []); const PROMPTS = useMemo(() => { if (typeof window !== 'undefined') { const rawIds = new Set(RAW.map(p => p.id)); RAW.forEach(p => { if (!text[p.id]) console.warn('[prompt-library] no text[] entry for id:', p.id); }); Object.keys(text).forEach(k => { if (!rawIds.has(k)) console.warn('[prompt-library] orphaned text[] key:', k); }); } return RAW.map(p => ({ ...p, title: p.id, teaches: '', ...text[p.id] || ({}) })); }, [RAW, text]); const L = labels; const TL = k => tagLabels[k] || k; const CAT_TAG = useMemo(() => ({ Onboard: 'understand', Understand: 'understand', Plan: 'plan', Prototype: 'prototype', Implement: 'build', Test: 'test', Refactor: 'refactor', Review: 'review', Steer: 'steer', Git: 'git', Release: 'release', Debug: 'debug', Incident: 'debug', Data: 'data', Automate: 'automate' }), []); const TAGS = useMemo(() => ['understand', 'plan', 'prototype', 'build', 'test', 'refactor', 'review', 'steer', 'debug', 'git', 'release', 'data', 'automate', 'pm', 'design', 'docs', 'marketing', 'security', 'ops'], []); const tagsOf = p => [CAT_TAG[p.cat], ...p.roles || []]; const doc = useMemo(() => { const p = typeof window !== 'undefined' ? window.location.pathname : ''; const base = p.startsWith('/docs/') ? '/docs' : ''; const m = p.slice(base.length).match(/^/([a-z]{2}(?:-[A-Z]{2})?)//); const locale = m ? m[1] : 'en'; return href => { if (!href) return undefined; if (href[0] === '#' || href.startsWith('https://')) return href; if (!(/^/[A-Za-z0-9]/).test(href)) return undefined; return base + (href.startsWith('/en/') ? '/' + locale + href.slice(3) : href); }; }, []); const SAFE_HREF = /^(/(?![/\\s])|#|https?://)/; const linkify = s => { const out = []; let last = 0; const re = /[([^]]+)](([^)]+))/g; for (let m; m = re.exec(s); ) { if (m.index > last) out.push(s.slice(last, m.index)); out.push(SAFE_HREF.test(m[2]) ? {m[1]} : m[1]); last = re.lastIndex; } if (last < s.length) out.push(s.slice(last)); return out; }; const codeify = s => s.split(/([^]+)/g).map((part, i) => part[0] === '' ? {part.slice(1, -1)} : part); const SOURCES = useMemo(() => ({ 'workflows': '/en/common-workflows', 'teams': 'https://claude.com/blog/how-anthropic-teams-use-claude-code', 'legal': 'https://claude.com/blog/how-anthropic-uses-claude-legal', 'cybersecurity': 'https://claude.com/blog/how-anthropic-uses-claude-cybersecurity', 'best-practices': '/en/best-practices', 'ebook': 'https://resources.anthropic.com/hubfs/Scaling%20agentic%20coding%20across%20your%20organization.pdf' }), []); const [mounted, setMounted] = useState(false); const [q, setQ] = useState(''); const [start, setStart] = useState(true); const [sel, setSel] = useState(null); const [openId, setOpenId] = useState(null); const [copied, setCopied] = useState(null); const [fills, setFills] = useState({}); const copyTimer = useRef(null); useEffect(() => { setMounted(true); return () => clearTimeout(copyTimer.current); }, []); const setFill = (id, key, val) => setFills(f => ({ ...f, [id + '.' + key]: val })); const fillOf = (p, key) => { const v = fills[p.id + '.' + key]; return v !== undefined ? v : p.slots && p.slots[key] !== undefined ? p.slots[key] : ''; }; const assemble = p => p.prompt.replace(/{(\w+)}/g, (, k) => fillOf(p, k) || p.slots && p.slots[k] || k); const preview = p => p.prompt.replace(/{(\w+)}/g, (, k) => p.slots && p.slots[k] || k); const bodyText = p => preview(p) + ' ' + p.teaches.replace(/[([^]]+)]([^)]+)/g, '$1') + ' ' + (p.next || ''); const WIDE_RE = /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6]/g; const widthFor = s => { const t = typeof s === 'string' ? s : ''; return t.length + (t.match(WIDE_RE) || []).length + 3 + 'ch'; }; const ql = q.trim().toLowerCase(); const toggleTag = k => { setStart(false); setSel(s => !ql && s === k ? null : k); }; const clear = () => { setStart(false); setSel(null); setQ(''); }; const results = useMemo(() => { const list = PROMPTS.filter(p => { if (ql) return p.title.toLowerCase().includes(ql) || bodyText(p).toLowerCase().includes(ql); if (start) return !!p.startN; if (sel) return tagsOf(p).includes(sel); return true; }); if (ql) return list; if (start) return list.sort((a, b) => a.startN - b.startN); if (sel) return list.sort((a, b) => (a.roles || []).length - (b.roles || []).length || (b.sdlc === 'operate') - (a.sdlc === 'operate')); return list; }, [PROMPTS, ql, start, sel]); const matchSnippet = p => { if (!ql || p.title.toLowerCase().includes(ql)) return null; const txt = bodyText(p); const at = txt.toLowerCase().indexOf(ql); if (at < 0) return null; const lo = Math.max(0, at - 30), hi = Math.min(txt.length, at + ql.length + 50); return [lo > 0 ? '…' : '', txt.slice(lo, at), {txt.slice(at, at + ql.length)}, txt.slice(at + ql.length, hi), hi < txt.length ? '…' : '']; }; const grouped = useMemo(() => { if (start && !q.trim()) return []; const g = {}; for (const p of results) { const key = p.sdlc + '|' + p.cat; (g[key] = g[key] || ({ sdlc: p.sdlc, cat: p.cat, items: [] })).items.push(p); } return Object.values(g); }, [results, start, q]); const copy = async (str, id) => { try { await navigator.clipboard.writeText(str); } catch { const ta = document.createElement('textarea'); ta.value = str; ta.setAttribute('readonly', ''); ta.style.position = 'fixed'; ta.style.opacity = '0'; document.body.appendChild(ta); ta.select(); document.execCommand('copy'); document.body.removeChild(ta); } clearTimeout(copyTimer.current); setCopied(id); copyTimer.current = setTimeout(() => setCopied(null), 1600); }; const promptBody = p => { if (!p.slots) return {p.prompt}; const parts = p.prompt.split(/({\w+})/g); return {parts.map((part, idx) => { const m = part.match(/^{(\w+)}$/); if (!m) return {part}; const k = m[1]; const val = fillOf(p, k); return <input key={idx} type="text" className="pl-slot" value={val} placeholder={p.slots[k] || k} aria-label={k} style={{ width: widthFor(val || p.slots[k]) }} onChange={e => setFill(p.id, k, e.target.value)} onFocus={e => e.target.select()} onClick={e => e.stopPropagation()} />; })} ; }; const card = p => { const open = openId === p.id; const srcHref = SOURCES[p.src]; const srcLabel = sourceLabels[p.src]; const snip = matchSnippet(p); return <div key={p.id} className={'pl-card' + (open ? ' pl-open' : '')}> <button type="button" className="pl-head" onClick={() => setOpenId(open ? null : p.id)} aria-expanded={open}> {p.title} {!!p.startN && {L.startHere} · {p.startN}} {snip ?

{snip}
: {preview(p)}} {open &&
{p.slots ? L.fillAndCopy : L.copyThis}
{p.needs && L.needs && L.needs[p.needs] &&
{L.needsLabel} {linkify(L.needs[p.needs])}
} {p.paste && L.paste && L.paste[p.paste] &&
{L.paste[p.paste]}
} {p.slots &&
{L.hintBefore} {L.hintChip} {L.hintAfter}
}
{'❯'} {promptBody(p)} <button type="button" className="pl-copy" onClick={() => copy(assemble(p), p.id)}> {copied === p.id ? L.copied : L.copy}
{L.whyWorks}
{linkify(p.teaches)}
{p.nextHref && p.next && SAFE_HREF.test(p.nextHref) &&
{L.makeItStick} {codeify(p.next)} →
} {srcLabel &&
{L.from} {srcHref ? {srcLabel} : srcLabel}
}
}
; }; const STYLES = useMemo(() => ` .pl { --pl-accent: #D97757; --pl-accent-bg: rgba(217,119,87,0.07); --pl-bg: #fff; --pl-surface: #FAFAF7; --pl-border: #E8E6DC; --pl-border-subtle: rgba(31,30,29,0.08); --pl-text: #141413; --pl-text-2: #5E5D59; --pl-text-3: #73726C; --pl-text-4: #9C9A92; --pl-mono: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace); font-family: 'Anthropic Sans', -apple-system, BlinkMacSystemFont, sans-serif; font-size: 16px; color: var(--pl-text); margin: 8px 0 32px; } .dark .pl { --pl-bg: #1f1e1d; --pl-surface: #262624; --pl-border: #3d3d3a; --pl-border-subtle: rgba(240,238,230,0.08); --pl-text: #f0eee6; --pl-text-2: #bfbdb4; --pl-text-3: #91908a; --pl-text-4: #73726c; } .pl *, .pl *::before, .pl *::after { box-sizing: border-box; } .pl button { font-family: inherit; cursor: pointer; } .pl a { color: var(--pl-accent); text-decoration: none; } .pl a:hover { text-decoration: underline; }

.pl-search { display: flex; align-items: center; gap: 10px; padding: 14px 18px; background: var(--pl-surface); border: 1px solid var(--pl-border); border-radius: 12px; margin-bottom: 14px; } .pl-search input { flex: 1; border: none; outline: none; background: transparent; font-size: 16px; color: var(--pl-text); } .pl-search input::placeholder { color: var(--pl-text-4); }

.pl-tags { display: flex; gap: 8px; flex-wrap: wrap; align-items: center; margin-bottom: 18px; } .pl-tag { padding: 7px 14px; border: 1px solid var(--pl-border); background: var(--pl-bg); font-size: 14px; color: var(--pl-text-2); border-radius: 999px; } .pl-tag:hover { background: var(--pl-surface); } .pl-tag.pl-on { background: var(--pl-text); border-color: var(--pl-text); color: var(--pl-bg); } .pl-tag.pl-start { color: var(--pl-accent); font-weight: 500; } .pl-tag.pl-start.pl-on { background: var(--pl-accent); border-color: var(--pl-accent); color: #fff; } .pl-tags.pl-dim .pl-tag { opacity: 0.5; } .pl-tags.pl-dim .pl-tag:hover { opacity: 1; } .pl-sep { width: 1px; height: 22px; background: var(--pl-border); margin: 0 4px; } .pl-clear { border: none; background: none; font-size: 13px; color: var(--pl-text-4); padding: 4px 6px; } .pl-clear:hover { color: var(--pl-text-2); } .pl-count { margin-left: auto; font-size: 14px; color: var(--pl-text-4); }

.pl-group-h { font-size: 12px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--pl-text-4); margin: 24px 0 12px; } .pl-group-h .pl-phase { color: var(--pl-text-3); } .pl-card { border: 1px solid var(--pl-border-subtle); border-radius: 10px; margin-bottom: 12px; background: var(--pl-bg); overflow: hidden; padding: 14px 18px; } .pl-card.pl-open { border-color: var(--pl-border); background: var(--pl-surface); } .pl-head { width: 100%; display: flex; align-items: baseline; gap: 12px; border: none; background: transparent; text-align: left; padding: 0; } .pl-head:focus-visible { outline: 2px solid var(--pl-accent); outline-offset: 2px; border-radius: 6px; } .pl-title { flex: 1; font-size: 17px; font-weight: 500; color: var(--pl-text); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } .pl-prompt-preview { display: block; font-family: var(--pl-mono); font-size: 13.5px; color: var(--pl-text-3); margin-top: 6px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } .pl-chip { font-size: 11px; letter-spacing: 0.05em; text-transform: uppercase; padding: 3px 9px; border-radius: 999px; flex-shrink: 0; background: var(--pl-accent-bg); color: var(--pl-accent); }

.pl-body { margin-top: 14px; padding-top: 14px; border-top: 1px solid var(--pl-border-subtle); } .pl-label { font-size: 11.5px; letter-spacing: 0.08em; text-transform: uppercase; color: var(--pl-text-4); margin: 12px 0 8px; } .pl-prompt-box { display: flex; align-items: center; gap: 10px; padding: 14px 16px; background: #141413; color: #f0eee6; border-radius: 8px; font-family: var(--pl-mono); font-size: 15px; } .pl-caret { color: var(--pl-accent); flex-shrink: 0; } .pl-prompt-box code { flex: 1; background: none; padding: 0; color: inherit; white-space: pre-wrap; line-height: 1.9; } .pl-slot { font-family: var(--pl-mono); font-size: inherit; background: rgba(217,119,87,0.15); color: #f0eee6; border: none; border-bottom: 1.5px dashed var(--pl-accent); border-radius: 4px 4px 0 0; padding: 2px 6px; margin: 0 1px; outline: none; min-width: 6ch; max-width: 100%; box-sizing: content-box; cursor: text; } .pl-slot:hover { background: rgba(217,119,87,0.22); } .pl-slot:focus { background: rgba(217,119,87,0.28); border-bottom-style: solid; } .pl-slot::placeholder { color: rgba(240,238,230,0.4); font-style: italic; } .pl-hint { font-size: 14px; color: var(--pl-text-3); margin: 0 0 10px; } .pl-paste { color: var(--pl-text-2); } .pl-needs { color: var(--pl-text-2); } .pl-needs-label { display: inline-block; font-size: 10.5px; letter-spacing: 0.06em; text-transform: uppercase; padding: 2px 7px; margin-right: 6px; border-radius: 4px; background: var(--pl-accent-bg); color: var(--pl-accent); } .pl-hint-chip { font-family: var(--pl-mono); font-size: 0.92em; background: var(--pl-accent-bg); color: var(--pl-accent); border-bottom: 1.5px dashed var(--pl-accent); border-radius: 3px 3px 0 0; padding: 1px 5px; } .pl-copy { font-size: 12.5px; padding: 6px 12px; border-radius: 6px; background: var(--pl-accent); color: #fff; border: none; flex-shrink: 0; } .pl-teaches { display: block; font-size: 15.5px; color: var(--pl-text-2); margin: 4px 0 0; line-height: 1.6; } .pl-match { display: block; font-size: 13.5px; color: var(--pl-text-3); margin-top: 6px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; } .pl-match mark { background: var(--pl-accent-bg); color: var(--pl-text); padding: 1px 2px; border-radius: 3px; } .pl-next { display: flex; align-items: baseline; gap: 10px; margin: 14px 0 0; padding: 10px 12px; background: var(--pl-accent-bg); border-radius: 8px; font-size: 14.5px; } .pl-next-label { font-size: 11px; letter-spacing: 0.06em; text-transform: uppercase; color: var(--pl-accent); font-weight: 600; flex-shrink: 0; } .pl-src { display: block; font-size: 14px; color: var(--pl-text-4); margin: 14px 0 0; }

.pl-show-all { display: block; width: 100%; padding: 14px; margin-top: 4px; border: 1px dashed var(--pl-border); border-radius: 10px; background: transparent; font-size: 15px; color: var(--pl-accent); text-align: center; } .pl-show-all:hover { background: var(--pl-accent-bg); border-style: solid; }

.pl-empty { padding: 32px; text-align: center; color: var(--pl-text-4); border: 1px dashed var(--pl-border); border-radius: 10px; } `, []); if (!mounted) return <div className="pl" style={{ minHeight: 480 }} />; return

  <div className="pl-search">
    <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" style={{
color: 'var(--pl-text-4)'

}}> <input type="text" placeholder={L.search} value={q} onChange={e => { setQ(e.target.value); if (e.target.value) setStart(false); }} aria-label={L.search} />

  <div className={'pl-tags' + (ql ? ' pl-dim' : '')}>
    <button type="button" className={'pl-tag pl-start' + (!ql && start ? ' pl-on' : '')} onClick={() => {
setQ('');
setStart(!start);
if (!start) setSel(null);

}}> ★ {L.startHere} {TAGS.map(k => <button key={k} type="button" aria-pressed={!ql && sel === k} className={'pl-tag' + (!ql && sel === k ? ' pl-on' : '')} onClick={() => { setQ(''); toggleTag(k); }}> {TL(k)} )} {(start || sel || q) && } {results.length} {results.length === 1 ? L.prompt : L.prompts}

  {results.length === 0 ? <div className="pl-empty">
      {L.noMatch} {ql ? <code>{q}</code> : null} <button type="button" className="pl-clear" onClick={clear}>{L.clear}</button>
    </div> : !ql && start ? <div>
      <div className="pl-group-h">{L.startHereHeader}</div>
      {results.map(card)}
      <button type="button" className="pl-show-all" onClick={clear}>
        {L.showAll && L.showAll.replace('{n}', PROMPTS.length)} →
      </button>
    </div> : grouped.map(g => <div key={g.sdlc + '|' + g.cat}>
        <div className="pl-group-h"><span className="pl-phase">{phaseLabels[g.sdlc] || g.sdlc}</span> · {catLabels[g.cat] || g.cat}</div>
        {g.items.map(card)}
      </div>)}
</div>;

};

Esta es una biblioteca de prompts para copiar en Claude Code. Úsela para explorar formas de trabajo que no ha probado, o cuando no esté seguro de dónde empezar.

Los prompts se recopilan de varias guías de Anthropic, incluyendo Flujos de trabajo comunes, Mejores prácticas, y Cómo los equipos de Anthropic usan Claude Code. Son puntos de partida en lugar de scripts. Abra Por qué funciona esto bajo cualquier prompt para ver el patrón detrás de él para que pueda escribir el suyo propio.

export const labels = { startHere: "Comience aquí", startHereHeader: "Cinco prompts para probar primero", showAll: "Mostrar todos los {n} prompts", search: "Buscar prompts…", clear: "Limpiar", prompt: "prompt", prompts: "prompts", noMatch: "Ningún prompt coincide", fillAndCopy: "Rellenar y copiar", copyThis: "Copiar este prompt", hintBefore: "Escriba en los", hintChip: "campos destacados", hintAfter: "para personalizar, luego copie.", copy: "Copiar", copied: "Copiado", whyWorks: "Por qué funciona esto", makeItStick: "Hacerlo permanente", from: "De", paste: { mockup: "Pegue, arrastre o @-mencione su imagen de maqueta, luego envíe esto:", design: "Pegue, arrastre o @-mencione su imagen de diseño, luego envíe esto:", screenshot: "Pegue, arrastre o @-mencione su captura de pantalla, luego envíe esto:", plan: "Pegue su salida de plan en el prompt primero, luego envíe esto:", error: "Pegue la salida de error en el prompt primero, luego envíe esto:", csv: "Arrastre su archivo al prompt, o reemplace la ruta a continuación con una @-mención de la suya:" }, needsLabel: "Necesita", needs: { tracker: "su rastreador de problemas agregado como un conector de claude.ai o servidor MCP.", gh: "la CLI gh autenticada, o GitHub agregado como un conector de claude.ai.", browser: "una forma para que Claude renderice y capture una captura de pantalla del resultado. La aplicación de escritorio tiene esto integrado. En la terminal, instale la extensión de Chrome o un servidor MCP de Playwright.", db: "su almacén de datos o almacén de registros agregado como un conector de claude.ai o servidor MCP." } };

export const tagLabels = { understand: "Entender", plan: "Plan", prototype: "Prototipo", build: "Construir", test: "Prueba", refactor: "Refactorizar", review: "Revisar", steer: "Dirigir", debug: "Depurar", git: "Git", release: "Lanzamiento", data: "Datos", automate: "Automatizar", pm: "Producto", design: "Diseño", docs: "Documentación", marketing: "Marketing", security: "Seguridad", ops: "En guardia" };

export const phaseLabels = { discover: "Descubrir", design: "Diseño", build: "Construir", ship: "Enviar", operate: "Operar" };

export const sourceLabels = { workflows: "Flujos de trabajo comunes", teams: "Cómo los equipos de Anthropic usan Claude Code", legal: "Cómo Anthropic usa Claude en Legal", cybersecurity: "Cómo Anthropic usa Claude en Ciberseguridad", "best-practices": "Mejores prácticas", ebook: "Guía de codificación agéntica escalable" };

export const catLabels = { Onboard: "Incorporar", Understand: "Entender", Plan: "Plan", Prototype: "Prototipo", Implement: "Implementar", Test: "Prueba", Refactor: "Refactorizar", Review: "Revisar", Steer: "Dirigir", Git: "Git", Release: "Lanzamiento", Debug: "Depurar", Incident: "Incidente", Data: "Datos", Automate: "Automatizar" };

export const text = { "get-oriented-in-a": { title: "Orientarse en un repositorio nuevo", teaches: "Describe lo que quieres saber, no qué archivos leer. Claude explora el proyecto por su cuenta y devuelve un resumen de cómo encaja todo.", next: "Ejecuta /init para configurar CLAUDE.md y que Claude recuerde esto en cada sesión", prompt: "dame una visión general de esta base de código: arquitectura, directorios clave y cómo se conectan las piezas" }, "explain-unfamiliar-code": { title: "Explicar código desconocido", teaches: "Nombra el archivo y di en qué formato quieres la respuesta. Cambia la página HTML por un diagrama, viñetas o lo que mejor se adapte a tu forma de aprender.", next: "Establece un estilo de salida para que Claude siempre explique en tu formato preferido", prompt: "explica qué hace {path} y cómo fluyen los datos a través de él. escríbelo como {format}", slots: { path: "src/scheduler/queue.ts", format: "una página HTML con un diagrama y luego ábrela en mi navegador" } }, "find-where-something-happens": { title: "Encontrar dónde sucede algo", teaches: "Busca por comportamiento en lugar de por nombre de archivo. La búsqueda funciona incluso cuando no sabes cómo se llama el archivo ni en qué directorio está.", prompt: "¿dónde {behavior}?", slots: { behavior: "validamos los tipos de archivos subidos" } }, "see-what-depends-on": { title: "Verificar qué se rompe antes de eliminar", teaches: "Pregunta antes de eliminar cualquier cosa. La lista de llamadores y efectos posteriores te dice si se trata de una limpieza de una línea o de un cambio que necesitas coordinar.", prompt: "¿qué se rompería si eliminara {target}?", slots: { target: "el helper retryWithBackoff" } }, "trace-how-code-evolved": { title: "Rastrear cómo evolucionó el código", teaches: "Apunta al historial de commits cuando la pregunta es por qué, no qué. Claude lee el registro y el blame del control de versiones que uses y explica las decisiones detrás de la implementación actual.", prompt: "revisa el historial de commits de {path} y resume cómo evolucionó y por qué", slots: { path: "internal/auth/session.go" } }, "scope-a-change-before": { title: "Definir el alcance de un cambio antes de comenzar", teaches: "Dimensiona el trabajo antes de comprometerlo en una hoja de ruta. La lista de archivos te dice si se trata de un solo componente o de un cambio transversal.", prompt: "¿qué archivos tendría que modificar para {change}?", slots: { change: "agregar un interruptor de modo oscuro a la configuración" } }, "ask-the-codebase-a": { title: "Hacer una pregunta de producto a la base de código", teaches: "Indica tu rol para que la respuesta tenga el nivel adecuado. Claude explica qué hace realmente el producto a partir del código fuente, sin que necesites leerlo.", next: "Establece un estilo de salida para que Claude siempre responda a este nivel", prompt: "soy {role}. explícame paso a paso qué pasa cuando un usuario {action}, desde la UI hasta el resultado", slots: { role: "PM", action: "hace clic en Exportar a PDF" } }, "plan-a-multi-file": { title: "Planificar un cambio de múltiples archivos antes de tocar código", teaches: "Agregar "no edites nada todavía" separa la exploración de los cambios, así ves el enfoque antes de que se mueva cualquier código. Para que planificar primero sea lo predeterminado en cada prompt, presiona Shift+Tab para entrar en modo plan.", prompt: "planifica cómo refactorizar el {target} para {goal}. enumera los archivos que cambiarías, pero no edites nada todavía", slots: { target: "módulo de pagos", goal: "admitir múltiples monedas" } }, "draft-a-spec-by": { title: "Redactar una especificación mediante una entrevista", teaches: "Pide que te entrevisten en lugar de escribir la especificación tú mismo. Claude te hace preguntas estructuradas hasta completar los requisitos y luego escribe el resultado en un archivo.", next: "Guarda tus preguntas de entrevista como un skill /spec para que cada especificación empiece igual", prompt: "quiero crear {feature}. entrevístame sobre la implementación, la UX, los casos límite y las compensaciones hasta que hayamos cubierto todo, luego escribe la especificación en SPEC.md", slots: { feature: "rate limits por espacio de trabajo" } }, "turn-a-meeting-into": { title: "Convertir una reunión en tickets", teaches: "Sáltate el paso de transcripción. Claude extrae las tareas pendientes de la entrada no estructurada y las escribe directamente en tu gestor mediante MCP, así revisas los tickets, no la transcripción.", next: "Guarda esto como un skill /tickets", prompt: "lee {input} y redacta las tareas pendientes, luego crea un ticket de {tracker} para cada una con criterios de aceptación", slots: { input: "@meeting-notes.md", tracker: "Linear" } }, "map-edge-cases-before": { title: "Mapear casos límite antes de desarrollar", teaches: "Pregunta por lo que falta, no por lo que hay. Claude enumera los estados de error, los estados vacíos y los casos límite que un diseño centrado en el camino feliz suele omitir.", prompt: "enumera los estados de error, los estados vacíos y los casos límite de {feature} que el diseño necesita cubrir", slots: { feature: "el flujo de carga de archivos" } }, "turn-a-mockup-into": { title: "Convertir una maqueta en un prototipo funcional", teaches: "Un prototipo en el que se puede hacer clic responde preguntas que una maqueta estática no puede. Entrega el código funcional a ingeniería en lugar de explicar las interacciones en un documento.", prompt: "aquí tienes una maqueta. crea un prototipo funcional en el que pueda hacer clic, que respete el diseño y los estados mostrados" }, "implement-from-a-screenshot": { title: "Implementar desde una captura de pantalla y autoverificar", teaches: "Esto le da a Claude un bucle de verificación: renderiza, compara con la imagen de origen e itera sin que tengas que señalar cada diferencia.", next: "Usa /goal para que Claude siga iterando hasta que las capturas de pantalla coincidan", prompt: "implementa este diseño, luego toma una captura de pantalla del resultado, compárala con el original y corrige cualquier diferencia" }, "follow-an-existing-pattern": { title: "Seguir un patrón existente", teaches: "Señala código que ya te guste. Sin una referencia, Claude recurre a buenas prácticas generales. Con una, se ajusta a las convenciones que tu base de código realmente usa.", next: "Pide a Claude que escriba en CLAUDE.md el patrón que siguió para que las sesiones futuras lo respeten sin la referencia", prompt: "mira cómo está implementado {example} para entender el patrón y luego crea {new} de la misma manera", slots: { example: "el handler de webhooks de GitHub", new: "un handler de webhooks de Stripe" } }, "add-a-small-well": { title: "Agregar una funcionalidad pequeña y bien definida", teaches: "Indica las entradas y salidas, no cómo implementarla. Claude encuentra dónde está el código similar y agrega el tuyo junto a él.", prompt: "agrega un endpoint {endpoint} que devuelva {payload}", slots: { endpoint: "/health", payload: "la versión de la app y el tiempo de actividad" } }, "build-a-small-internal": { title: "Crear una herramienta interna pequeña desde cero", teaches: "No necesitas un proyecto, un framework ni un paso de compilación. Describe la herramienta y pide a Claude que la abra para que la veas funcionando de inmediato.", prompt: "crea un {tool} usando HTML, CSS y JavaScript puro, luego ábrelo en mi navegador", slots: { tool: "tablero Kanban de arrastrar y soltar con tres columnas" } }, "work-an-issue-end": { title: "Resolver una incidencia de principio a fin", teaches: "Da el número de la incidencia, no un resumen. Claude lee el ticket completo por sí mismo, así que se incluyen los requisitos que olvidarías mencionar, y valida el cambio antes de informarte.", prompt: "lee la incidencia #{issue}, implementa la corrección y ejecuta las pruebas", slots: { issue: "312" } }, "find-and-update-copy": { title: "Encontrar y actualizar textos en toda la base de código", teaches: "Pide variantes y di qué omitir. Claude encuentra formulaciones que una búsqueda literal pasaría por alto y deja intactos los fixtures de prueba y el historial, así revisas solo el texto que los usuarios realmente ven.", prompt: "encuentra cada lugar donde decimos "{copy}" o una variante cercana, muéstrame cada uno en contexto y luego actualízalos todos a "{new}". no toques las pruebas ni el changelog", slots: { copy: "Regístrate gratis", new: "Comienza la prueba gratuita" } }, "draft-from-past-examples": { title: "Redactar un documento a partir de ejemplos anteriores", teaches: "Señala una carpeta de trabajos terminados en lugar de describir tu estilo. Claude aprende la estructura y la voz de lo que ya publicaste, así el primer borrador parece escrito por ti.", next: "Guarda la voz como un skill para que cada borrador parta de ahí", prompt: "lee las {examples} en {folder} para aprender la estructura y la voz, luego redacta una nueva para {topic}", slots: { examples: "evaluaciones de impacto en la privacidad", folder: "legal/pia/", topic: "la nueva integración de analítica" } }, "write-tests-run-them": { title: "Escribir pruebas, ejecutarlas y corregir fallos", teaches: "Pide escribir, ejecutar y corregir a la vez para que Claude itere sin detenerse a esperar instrucciones.", next: "Ejecuta /init para que Claude aprenda automáticamente tu comando de pruebas", prompt: "escribe pruebas para {path}, ejecútalas y corrige cualquier fallo", slots: { path: "app/parsers/feed.py" } }, "drive-implementation-from-tests": { title: "Guiar la implementación con pruebas", teaches: "Desarrollo guiado por pruebas: las pruebas definen cuándo está terminado el trabajo, y Claude itera sobre la implementación hasta que pasen.", prompt: "escribe primero las pruebas para {feature} y luego impleméntalo hasta que pasen", slots: { feature: "el flujo de restablecimiento de contraseña" } }, "fill-gaps-from-a": { title: "Cubrir huecos a partir de un informe de cobertura", teaches: "Señala el informe de cobertura en lugar de adivinar qué no está probado. Claude lee los números reales y escribe pruebas para los archivos que más las necesitan.", next: "Establece esto como un /goal para que Claude siga escribiendo pruebas hasta alcanzar el objetivo de cobertura", prompt: "lee {report} y agrega pruebas para los archivos con menor cobertura hasta que cada uno supere el {target}%", slots: { report: "coverage/coverage-summary.json", target: "80" } }, "port-code-between-languages": { title: "Portar código a otro lenguaje", teaches: "Di qué conservar, no solo el lenguaje de destino. Nombrar la API o el comportamiento que debe mantenerse igual le da a Claude un contrato con el que verificar la migración.", prompt: "porta {source} a {target}, conservando igual {keep}", slots: { source: "este módulo de Python", target: "Rust", keep: "la API pública y el comportamiento de las pruebas" } }, "generate-docs-for-code": { title: "Generar documentación para código sin documentar", teaches: "Nombra el alcance y el formato. Claude encuentra lo que falta y respeta el estilo de comentarios que ya usa el archivo, así la nueva documentación se lee como el resto.", prompt: "encuentra {scope} sin comentarios {format} y agrégalos, respetando el estilo que ya se usa en el archivo", slots: { scope: "las funciones públicas de src/auth/", format: "JSDoc" } }, "migrate-a-pattern-across": { title: "Migrar un patrón en toda la base de código", teaches: "Describe el patrón antiguo y el nuevo. Pedirle a Claude que identifique primero cada lugar hace que los puntos de llamada aparezcan en la respuesta, así puedes comprobar que no se omitió ninguno. Para una migración que abarca muchos archivos, ejecuta /batch. Claude divide el trabajo en unidades para que las apruebes y luego subagentes en segundo plano hacen los cambios.", prompt: "migra todo de {from} a {to}: identifica cada lugar que necesita cambiar y luego haz los cambios", slots: { from: "la API de logging antigua", to: "el logger estructurado" } }, "optimize-against-a-measurable": { title: "Optimizar hacia un objetivo medible", teaches: "Indicar la métrica y el objetivo le da a Claude una definición clara de cuándo está terminado.", next: "Establece esto como un /goal para que Claude siga midiendo e iterando hasta alcanzar el número", prompt: "optimiza {target} para bajar {metric} de {current} a menos de {goal}", slots: { target: "la consulta de búsqueda", metric: "la latencia p95", current: "2s", goal: "500ms" } }, "fix-a-precise-visual": { title: "Corregir un error visual preciso", teaches: "Un feedback visual preciso consigue una corrección precisa. Indica el elemento exacto, la medida y la ventana gráfica.", next: "Agrega una herramienta de vista previa para que Claude tome capturas de pantalla y verifique la corrección por sí mismo", prompt: "el {element} sobresale {amount} del {container} en {viewport}. corrígelo.", slots: { element: "botón de inicio de sesión", amount: "20px", container: "borde de la tarjeta", viewport: "móvil" } }, "review-your-changes-before": { title: "Revisar tus cambios antes de hacer commit", teaches: "Detecta problemas mientras todavía son baratos de corregir. Claude lee los archivos modificados completos, no solo las líneas del diff, así encuentra problemas que una autorrevisión rápida pasa por alto.", next: "Ejecuta /code-review para hacer la misma verificación con un solo comando", prompt: "revisa mis cambios sin commit y señala cualquier cosa que parezca riesgosa antes de hacer commit" }, "review-a-pull-request": { title: "Revisar un pull request", teaches: "Claude revisa con toda la base de código en contexto, no solo el diff. Lee el código modificado y lo que este llama, así detecta problemas que una revisión solo del diff pasaría por alto.", next: "Ejecuta /code-review <pr#> con un solo comando, o activa Code Review para cada PR", prompt: "revisa el PR #{pr} y resume qué cambió, luego enumera cualquier inquietud", slots: { pr: "247" } }, "review-infrastructure-changes-before": { title: "Revisar cambios de infraestructura antes de aplicarlos", teaches: "La salida del plan es densa y difícil de leer de un vistazo. Al pegarla obtienes un resumen en lenguaje sencillo de lo que realmente va a cambiar antes de aplicarlo.", prompt: "esta es la salida de mi plan de Terraform. ¿qué va a hacer y hay algo aquí que vaya a causar problemas?" }, "run-a-security-review": { title: "Ejecutar una revisión de seguridad con un subagente", teaches: "Un subagente ejecuta la auditoría en su propia ventana de contexto e informa un resumen, así una revisión de seguridad larga no llena tu sesión principal. El subagente integrado de propósito general se encarga de esto sin configuración adicional.", next: "Configura un subagente dedicado a revisiones de seguridad que todo tu equipo pueda usar", prompt: "usa un subagente para revisar {path} en busca de problemas de seguridad e informa lo que encuentre", slots: { path: "src/api/" } }, "review-content-before-sending": { title: "Detectar problemas antes de la revisión formal", teaches: "Obtén una primera revisión antes de que una persona le dedique tiempo. Nombra los aspectos que quieres revisar para que la revisión esté enfocada, luego corrige lo que encuentre y envía un borrador más limpio.", next: "Convierte tu lista de verificación de revisión en un skill que todo tu equipo pueda ejecutar", prompt: "revisa {file} en busca de {concerns} y enumera todo lo que debería corregir antes de que llegue a {reviewer}", slots: { file: "launch-post.md", concerns: "afirmaciones sin respaldo, atribuciones faltantes y problemas con las pautas de marca", reviewer: "el equipo legal" } }, "course-correct-a-wrong": { title: "Corregir un enfoque incorrecto", teaches: "Nombra la restricción que Claude pasó por alto, no solo que está mal. Una razón específica le da a Claude una restricción concreta que cumplir en el reintento, en lugar de volver a adivinar.", next: "Presiona Esc dos veces para abrir el menú de rebobinado y restaurar el código y la conversación, así el reintento empieza desde cero", prompt: "eso no es correcto: {feedback}. prueba un enfoque diferente", slots: { feedback: "la firma de la función debe seguir siendo compatible con versiones anteriores" } }, "narrow-the-scope-of": { title: "Reducir el alcance de un cambio", teaches: "Cuando la dirección es correcta pero el cambio se extendió demasiado, pide a Claude que conserve una parte en lugar de rebobinar todo. Un límite explícito evita que una corrección pequeña se convierta en una refactorización.", prompt: "eso es demasiado. conserva solo los cambios en {scope} y deshaz tus otras ediciones", slots: { scope: "la lógica de validación en src/forms/" } }, "turn-a-correction-into": { title: "Convertir una corrección en una regla", teaches: "Una corrección en el chat no se comparte con tu equipo. Una regla en el CLAUDE.md del proyecto se comparte en cuanto haces commit de ella, y Claude la lee al inicio de cada sesión.", next: "Abre /memory para revisar lo que escribió Claude", prompt: "sigues {mistake}. agrega una regla a CLAUDE.md para que esto deje de pasar", slots: { mistake: "usando exports por defecto cuando este proyecto usa exports con nombre" } }, "resolve-merge-conflicts": { title: "Resolver conflictos de fusión", teaches: "Di qué estado quieres, no qué marcadores conservar. Pedir el razonamiento hace que la fusión se pueda revisar en lugar de ser una caja negra.", prompt: "resuelve los conflictos de fusión en esta rama y explica qué conservaste de cada lado" }, "commit-with-a-generated": { title: "Hacer commit con un mensaje generado", teaches: "Deja que Claude derive el mensaje a partir del diff. Se ajusta al estilo de commits que ya usa tu repositorio.", prompt: "haz commit de estos cambios con un mensaje que resuma lo que hice" }, "open-a-pull-request": { title: "Abrir un pull request desde un ticket", teaches: "Evita cambiar de contexto entre el gestor de tickets, el editor y GitHub. Un solo prompt lee la especificación, hace el cambio y abre el PR.", prompt: "encuentra el ticket de {tracker} sobre {topic} y abre un PR que lo implemente", slots: { tracker: "Linear", topic: "el tiempo de espera del inicio de sesión" } }, "draft-release-notes-from": { title: "Redactar notas de la versión a partir del historial de git", teaches: "Da dos puntos de referencia y la estructura que quieres. Claude lee el registro de commits entre ellos y redacta un changelog que puedes editar.", next: "Guarda esto como un skill /changelog", prompt: "compara {from} con {to} y redacta notas de la versión agrupadas por funcionalidad, corrección y cambio incompatible", slots: { from: "v2.3.0", to: "v2.4.0" } }, "write-a-ci-workflow": { title: "Escribir un workflow de CI", teaches: "Describe cuándo debe ejecutarse y qué debe hacer; el YAML se genera por ti, adaptado a los comandos de compilación y pruebas de tu proyecto.", prompt: "escribe un workflow de GitHub Actions que {steps} en cada push a {branch}", slots: { steps: "ejecute las pruebas y despliegue en staging", branch: "main" } }, "find-and-fix-a": { title: "Encontrar y corregir una prueba fallida", teaches: "Describe el síntoma; no necesitas saber qué archivo está roto. Claude ejecuta la prueba para ver el fallo, lo rastrea hasta el código fuente y lo corrige.", prompt: "la prueba {test} está fallando, averigua por qué y corrígela", slots: { test: "UserAuth" } }, "investigate-a-reported-error": { title: "Investigar un error reportado", teaches: "Describe el síntoma y la ubicación; Claude lee la ruta de código relevante y rastrea las causas probables. Pega stack traces o registros si los tienes.", next: "Pon un deeplink en tu runbook que abra Claude con este prompt ya rellenado", prompt: "los usuarios están viendo {symptom} en {where}. investiga y dime qué está pasando", slots: { symptom: "errores 500", where: "/api/settings" } }, "fix-a-build-error": { title: "Corregir un error de compilación de raíz", teaches: "Pedir la causa raíz y la verificación evita parches superficiales que suprimen el error sin corregirlo.", prompt: "aquí tienes un error de compilación. corrige la causa raíz y verifica que la compilación funcione" }, "investigate-a-production-incident": { title: "Investigar un incidente de producción", teaches: "Enumera las fuentes de evidencia que hay que correlacionar, no los pasos a seguir. Claude lee los registros, el historial de git y la configuración en conjunto para acotar la causa.", next: "Conecta Sentry o tu almacén de registros mediante MCP", prompt: "{symptom}. revisa los registros, los despliegues recientes y los cambios de configuración, y luego dime la causa más probable", slots: { symptom: "el endpoint de checkout empezó a devolver errores 500 hace una hora" } }, "query-logs-in-plain": { title: "Consultar registros en lenguaje natural", teaches: "Haz la pregunta en lugar de escribir el SQL. Claude crea la consulta, la ejecuta contra tus registros conectados y muestra tanto la consulta como el resultado para que puedas comprobar qué se ejecutó.", prompt: "muéstrame todos los {events} de {scope} en {timeframe}. escribe la consulta, ejecútala y dime qué llama la atención", slots: { events: "inicios de sesión fallidos", scope: "el servicio de autenticación", timeframe: "las últimas 24 horas" } }, "diagnose-from-a-console": { title: "Diagnosticar desde una captura de pantalla de la consola", teaches: "Las consolas en la nube te muestran el problema, pero no los comandos para corregirlo. Claude lee la captura de pantalla y traduce el panel a los comandos de kubectl, gcloud o aws que debes ejecutar.", prompt: "esta es una captura de pantalla de {console}. explícame paso a paso por qué {resource} está fallando y dame los comandos exactos para corregirlo", slots: { console: "el panel de Kubernetes de GCP", resource: "este pod" } }, "analyze-a-data-file": { title: "Analizar un archivo de datos", teaches: "Una pregunta puntual no necesita un script hecho a medida. Señala un archivo en la carpeta de tu proyecto y Claude lo lee directamente, encuentra los patrones y escribe la salida donde le pidas.", next: "Conecta la fuente de datos mediante MCP en lugar de exportar archivos", prompt: "lee {file}, resume los patrones clave y escribe los resultados en {output}", slots: { file: "@reports/q1-signups.csv", output: "una página HTML con gráficos y luego ábrela en mi navegador" } }, "generate-variations-from-performance": { title: "Generar variaciones a partir de datos de rendimiento", teaches: "Indica la restricción desde el principio para que lo generado se mantenga dentro del límite. Claude lee las métricas, elige qué reemplazar y produce alternativas que se ajusten.", next: "Conecta la plataforma de anuncios mediante MCP en lugar de exportar un archivo", prompt: "lee {file}, encuentra los {items} con peor rendimiento y genera {n} variaciones nuevas de menos de {limit} caracteres", slots: { file: "@ads-performance.csv", items: "titulares", n: "20", limit: "90" } }, "turn-a-recurring-task": { title: "Convertir una tarea recurrente en un skill", teaches: "Nombra los pasos una vez; reutilízalos como un comando. Claude escribe un skill que cualquier persona de tu equipo puede ejecutar.", prompt: "crea un skill /{name} para este proyecto que {steps}", slots: { name: "ship", steps: "ejecute el linter y las pruebas y luego redacte un mensaje de commit" } }, "add-a-hook-for": { title: "Agregar un hook para un comportamiento repetido", teaches: "Los hooks hacen que un comportamiento sea automático en lugar de algo que tienes que acordarte de pedir. Describe el disparador y la acción, y Claude escribe la configuración del hook.", prompt: "escribe un hook que {action} después de cada {event}", slots: { action: "ejecute prettier", event: "edición de un archivo .ts o .tsx" } }, "connect-a-tool-with": { title: "Conectar una herramienta con MCP", teaches: "Conecta la fuente una vez en lugar de pegar datos en cada sesión. Tras configurar MCP, Claude lee directamente de la herramienta cuando le preguntas por ella.", prompt: "configura el servidor MCP de {server} para que puedas leer mis {data} directamente", slots: { server: "Sentry", data: "informes de errores" } }, "capture-what-to-remember": { title: "Capturar qué recordar para la próxima vez", teaches: "Pregunta antes de que se te olvide. Claude sabe qué tuvo que averiguar en esta sesión y propone entradas para CLAUDE.md para que la siguiente sesión empiece con ese contexto.", prompt: "resume lo que hicimos en esta sesión y sugiere qué agregar a CLAUDE.md" } };

Qué hace que estos prompts funcionen

Los prompts anteriores comparten algunos patrones. Reconocerlos le ayuda a adaptar cualquier prompt aquí a su propia tarea.

Describa el resultado, no los pasos. Diga qué desea y deje que Claude encuentre los archivos. El prompt a continuación funciona sin nombrar una sola ruta de archivo.

agregar limitación de velocidad a la API pública y asegurarse de que las pruebas existentes aún pasen

Déle una forma de verificar su propio trabajo. Pida ejecutar, probar, comparar o verificar en el mismo prompt para que Claude itere en lugar de detenerse después de un intento. Para verificar el cambio terminado contra la aplicación en ejecución, ejecute /verify.

escribir la migración, ejecutarla contra la base de datos de desarrollo y confirmar que el esquema coincida

Señale una referencia. Nombre un archivo, prueba o patrón existente para que coincida para que el nuevo código sea consistente con lo que ya tiene.

agregar una página de configuración que siga el mismo diseño que la página de perfil

Indique el objetivo medible. Cuando el objetivo es rendimiento o cobertura, dé la métrica y el umbral para que la finalización sea inequívoca.

obtener el tamaño del paquete por debajo de 200KB y mostrarme qué eliminó

Déle el artefacto. Pegue errores, registros, capturas de pantalla y salida de plan directamente en el prompt, o escriba @ para hacer referencia a un archivo. Claude lee la fuente en lugar de su descripción de ella.

¿por qué falla la compilación? @build.log

Diga cómo desea la respuesta. Nombre el formato, la longitud o la audiencia para que la explicación se ajuste a cómo la usará. Para hacer que un formato sea el predeterminado para cada respuesta, establezca un estilo de salida.

explicar cómo funciona la lógica de reintento de pago como una página HTML con un diagrama, luego abrirla en mi navegador

Para más información sobre cada patrón, consulte mejores prácticas.

De dónde vienen estos

Estos prompts se basan en patrones de recursos publicados de Anthropic. Cada tarjeta vincula a su fuente:

Para tutoriales en video de estos patrones, consulte el curso gratuito Claude Code in Action en Claude Academy.

Los prompts en esta página son puntos de partida. Una vez que uno funciona para su proyecto, el siguiente paso es hacerlo repetible: guárdelo como una habilidad para que cualquiera en su equipo pueda ejecutarlo como un /comando, y registre las convenciones que Claude aprendió en CLAUDE.md para que cada sesión comience con ese contexto en lugar de que Claude lo reaprendan. Para cambios más grandes o más riesgosos, plan mode le muestra la lista de archivos antes de que ocurran ediciones.

Si está introduciendo Claude Code en un equipo, consulte administración para configuración y política administrada, y costos y uso para saber cómo se factura este trabajo en su plan.