SpyBara
Go Premium

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

This page contains 331 additions and 108 deletions.

2026
Fri 2 09:02

Libreria di prompt

Copia e incolla prompt per Claude Code, etichettati per attività e ruolo.

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>;

};

Questa è una libreria di prompt da copiare in Claude Code. Utilizzatela per esplorare modi di lavorare che non avete ancora provato, o quando non siete sicuri da dove iniziare.

I prompt sono raccolti da varie guide Anthropic, tra cui Flussi di lavoro comuni, Best practice e Come i team di Anthropic utilizzano Claude Code. Sono punti di partenza piuttosto che script. Aprite Perché funziona sotto qualsiasi prompt per vedere il modello dietro di esso, così potrete scrivere i vostri.

export const labels = { startHere: "Iniziate da qui", startHereHeader: "Cinque prompt da provare per primi", showAll: "Mostra tutti i {n} prompt", search: "Cerca prompt…", clear: "Cancella", prompt: "prompt", prompts: "prompt", noMatch: "Nessun prompt corrisponde", fillAndCopy: "Compila e copia", copyThis: "Copia questo prompt", hintBefore: "Digitate nei", hintChip: "campi evidenziati", hintAfter: "per personalizzare, quindi copiate.", copy: "Copia", copied: "Copiato", whyWorks: "Perché funziona", makeItStick: "Rendilo permanente", from: "Da", paste: { mockup: "Incollate, trascinate o @-menzionate la vostra immagine mockup, quindi inviate questo:", design: "Incollate, trascinate o @-menzionate la vostra immagine di design, quindi inviate questo:", screenshot: "Incollate, trascinate o @-menzionate il vostro screenshot, quindi inviate questo:", plan: "Incollate l'output del vostro piano nel prompt per primo, quindi inviate questo:", error: "Incollate l'output dell'errore nel prompt per primo, quindi inviate questo:", csv: "Trascinate il vostro file nel prompt, o sostituite il percorso sottostante con una @-menzione della vostra:" }, needsLabel: "Richiede", needs: { tracker: "il vostro issue tracker aggiunto come connettore claude.ai o server MCP.", gh: "la gh CLI autenticata, o GitHub aggiunto come connettore claude.ai.", browser: "un modo per Claude di renderizzare e fare uno screenshot del risultato. L'app Desktop ha questa funzione integrata. Nel terminale, installate l'estensione Chrome o un server MCP Playwright.", db: "il vostro data warehouse o log store aggiunto come connettore claude.ai o server MCP." } };

export const tagLabels = { understand: "Comprendere", plan: "Pianificare", prototype: "Prototipo", build: "Costruire", test: "Test", refactor: "Refactoring", review: "Revisione", steer: "Guidare", debug: "Debug", git: "Git", release: "Release", data: "Dati", automate: "Automatizzare", pm: "Prodotto", design: "Design", docs: "Documentazione", marketing: "Marketing", security: "Sicurezza", ops: "On-call" };

export const phaseLabels = { discover: "Scoprire", design: "Progettare", build: "Costruire", ship: "Rilasciare", operate: "Operare" };

export const sourceLabels = { workflows: "Flussi di lavoro comuni", teams: "Come i team di Anthropic utilizzano Claude Code", legal: "Come Anthropic utilizza Claude in Legal", cybersecurity: "Come Anthropic utilizza Claude in Cybersecurity", "best-practices": "Best practice", ebook: "Guida al scaling del coding agentico" };

export const catLabels = { Onboard: "Onboard", Understand: "Comprendere", Plan: "Pianificare", Prototype: "Prototipo", Implement: "Implementare", Test: "Test", Refactor: "Refactoring", Review: "Revisione", Steer: "Guidare", Git: "Git", Release: "Release", Debug: "Debug", Incident: "Incidente", Data: "Dati", Automate: "Automatizzare" };

export const text = { "get-oriented-in-a": { title: "Orientarsi in un nuovo repository", teaches: "Descrivi quello che vuoi sapere, non quali file leggere. Claude esplora il progetto in autonomia e restituisce un riepilogo di come si incastrano le sue parti.", next: "Esegui /init per configurare CLAUDE.md in modo che Claude lo ricordi in ogni sessione", prompt: "dammi una panoramica di questo codebase: architettura, directory principali e come si collegano le varie parti" }, "explain-unfamiliar-code": { title: "Spiegare codice non familiare", teaches: "Indica il file e di' in quale formato vuoi la risposta. Sostituisci la pagina HTML con un diagramma, un elenco puntato o qualunque cosa si adatti al tuo modo di imparare.", next: "Imposta uno stile di output in modo che Claude spieghi sempre nel tuo formato preferito", prompt: "spiega cosa fa {path} e come i dati lo attraversano. scrivilo come {format}", slots: { path: "src/scheduler/queue.ts", format: "una pagina HTML con un diagramma, poi aprila nel mio browser" } }, "find-where-something-happens": { title: "Trovare dove accade qualcosa", teaches: "Cerca per comportamento invece che per nome file. La ricerca funziona anche quando non sai come si chiama il file o in quale directory si trova.", prompt: "dove {behavior}?", slots: { behavior: "convalidiamo i tipi di file caricati" } }, "see-what-depends-on": { title: "Controllare cosa si rompe prima di eliminare", teaches: "Chiedi prima di rimuovere qualcosa. L'elenco dei chiamanti e degli effetti a valle ti dice se si tratta di una pulizia di una riga o di una modifica che devi coordinare.", prompt: "cosa si romperebbe se eliminassi {target}?", slots: { target: "l'helper retryWithBackoff" } }, "trace-how-code-evolved": { title: "Tracciare come si è evoluto il codice", teaches: "Fai riferimento alla cronologia dei commit quando la domanda è il perché, non il cosa. Claude legge il log e il blame di qualsiasi sistema di controllo versione tu usi e spiega le decisioni dietro l'implementazione attuale.", prompt: "esamina la cronologia dei commit di {path} e riassumi come si è evoluto e perché", slots: { path: "internal/auth/session.go" } }, "scope-a-change-before": { title: "Definire la portata di una modifica prima di iniziare", teaches: "Valuta la dimensione del lavoro prima di inserirlo in una roadmap. L'elenco dei file ti dice se si tratta di un solo componente o di una modifica trasversale.", prompt: "quali file dovrei toccare per {change}?", slots: { change: "aggiungere un interruttore per la modalità scura nelle impostazioni" } }, "ask-the-codebase-a": { title: "Fare una domanda di prodotto al codebase", teaches: "Dichiara il tuo ruolo in modo che la risposta sia al livello giusto. Claude spiega cosa fa effettivamente il prodotto partendo dal codice sorgente, senza che tu debba leggerlo.", next: "Imposta uno stile di output in modo che Claude formuli sempre le risposte a questo livello", prompt: "sono un {role}. spiegami passo passo cosa succede quando un utente {action}, dall'interfaccia fino al risultato", slots: { role: "PM", action: "clicca su Esporta in PDF" } }, "plan-a-multi-file": { title: "Pianificare una modifica su più file prima di toccare il codice", teaches: "Aggiungere "non modificare ancora" separa l'esplorazione dalle modifiche, così vedi l'approccio prima che il codice venga toccato. Per rendere la pianificazione preventiva il comportamento predefinito per ogni prompt, premi Shift+Tab per attivare il plan mode.", prompt: "pianifica come fare il refactoring del {target} per {goal}. elenca i file che modificheresti, ma non modificare ancora nulla", slots: { target: "modulo dei pagamenti", goal: "supportare più valute" } }, "draft-a-spec-by": { title: "Scrivere una specifica tramite intervista", teaches: "Chiedi di essere intervistato invece di scrivere tu la specifica. Claude ti pone domande strutturate finché i requisiti non sono completi, poi scrive il risultato in un file.", next: "Salva le tue domande di intervista come skill /spec in modo che ogni specifica inizi allo stesso modo", prompt: "voglio creare {feature}. intervistami su implementazione, UX, casi limite e compromessi finché non avremo coperto tutto, poi scrivi la specifica in SPEC.md", slots: { feature: "rate limit per workspace" } }, "turn-a-meeting-into": { title: "Trasformare una riunione in ticket", teaches: "Salta il passaggio della trascrizione. Claude estrae le azioni da intraprendere dall'input non strutturato e le scrive direttamente nel tuo tracker tramite MCP, così rivedi i ticket, non la trascrizione.", next: "Salva questo come skill /tickets", prompt: "leggi {input} e scrivi le azioni da intraprendere, poi crea un ticket {tracker} per ciascuna con i criteri di accettazione", slots: { input: "@meeting-notes.md", tracker: "Linear" } }, "map-edge-cases-before": { title: "Mappare i casi limite prima di sviluppare", teaches: "Chiedi cosa manca, non cosa c'è. Claude elenca gli stati di errore, gli stati vuoti e i casi limite che un design pensato solo per il caso ideale tende a trascurare.", prompt: "elenca gli stati di errore, gli stati vuoti e i casi limite per {feature} che il design deve coprire", slots: { feature: "il flusso di caricamento dei file" } }, "turn-a-mockup-into": { title: "Trasformare un mockup in un prototipo funzionante", teaches: "Un prototipo cliccabile risponde a domande a cui un mockup statico non può rispondere. Consegna il codice funzionante al team di engineering invece di spiegare le interazioni in un documento.", prompt: "ecco un mockup. crea un prototipo funzionante in cui posso navigare cliccando, rispettando il layout e gli stati mostrati" }, "implement-from-a-screenshot": { title: "Implementare da uno screenshot e autoverificare", teaches: "Questo dà a Claude un ciclo di verifica: esegue il rendering, confronta il risultato con l'immagine sorgente e itera senza che tu debba segnalare ogni differenza.", next: "Usa /goal per far continuare Claude a iterare finché gli screenshot non corrispondono", prompt: "implementa questo design, poi fai uno screenshot del risultato, confrontalo con l'originale e correggi eventuali differenze" }, "follow-an-existing-pattern": { title: "Seguire uno schema esistente", teaches: "Indica del codice che ti piace già. Senza un riferimento, Claude segue le best practice generali. Con un riferimento, si adegua alle convenzioni che il tuo codebase usa effettivamente.", next: "Chiedi a Claude di scrivere in CLAUDE.md lo schema che ha seguito, in modo che le sessioni future lo rispettino senza il riferimento", prompt: "guarda come è implementato {example} per capire lo schema, poi crea {new} nello stesso modo", slots: { example: "l'handler dei webhook GitHub", new: "un handler per i webhook Stripe" } }, "add-a-small-well": { title: "Aggiungere una piccola funzionalità ben definita", teaches: "Dichiara gli input e gli output, non come realizzarla. Claude trova dove si trova il codice simile e aggiunge il tuo accanto.", prompt: "aggiungi un endpoint {endpoint} che restituisca {payload}", slots: { endpoint: "/health", payload: "la versione dell'app e l'uptime" } }, "build-a-small-internal": { title: "Creare un piccolo strumento interno da zero", teaches: "Non ti servono un progetto, un framework o un passaggio di build. Descrivi lo strumento e chiedi a Claude di aprirlo, così lo vedi funzionare immediatamente.", prompt: "crea una {tool} usando HTML, CSS e JavaScript vanilla, poi aprila nel mio browser", slots: { tool: "bacheca Kanban drag-and-drop con tre colonne" } }, "work-an-issue-end": { title: "Lavorare su una issue dall'inizio alla fine", teaches: "Fornisci il numero della issue, non un riepilogo. Claude legge da solo l'intero ticket, così emergono anche i requisiti che dimenticheresti di menzionare, e convalida la modifica prima di riferire.", prompt: "leggi la issue #{issue}, implementa la correzione ed esegui i test", slots: { issue: "312" } }, "find-and-update-copy": { title: "Trovare e aggiornare i testi in tutto il codebase", teaches: "Chiedi le varianti e di' cosa saltare. Claude trova formulazioni che una ricerca letterale non coglierebbe e lascia intatte le fixture di test e la cronologia, così rivedi solo i testi che gli utenti vedono effettivamente.", prompt: "trova ogni punto in cui diciamo "{copy}" o una variante simile, mostrami ciascuno nel suo contesto, poi aggiornali tutti in "{new}". lascia stare i test e il changelog", slots: { copy: "Registrati gratis", new: "Inizia la prova gratuita" } }, "draft-from-past-examples": { title: "Scrivere un documento partendo da esempi passati", teaches: "Indica una cartella di lavori finiti invece di descrivere il tuo stile. Claude impara la struttura e il tono da ciò che hai già pubblicato, così la prima bozza sembra scritta da te.", next: "Salva il tono come skill in modo che ogni bozza parta da lì", prompt: "leggi le {examples} in {folder} per imparare la struttura e il tono, poi scrivine una nuova per {topic}", slots: { examples: "valutazioni d'impatto sulla privacy", folder: "legal/pia/", topic: "la nuova integrazione di analytics" } }, "write-tests-run-them": { title: "Scrivere test, eseguirli, correggere gli errori", teaches: "Chiedi di scrivere, eseguire e correggere insieme, così Claude itera senza fermarsi ad aspettare istruzioni.", next: "Esegui /init in modo che Claude impari automaticamente il tuo comando di test", prompt: "scrivi i test per {path}, eseguili e correggi eventuali errori", slots: { path: "app/parsers/feed.py" } }, "drive-implementation-from-tests": { title: "Guidare l'implementazione con i test", teaches: "Test-driven development: i test definiscono quando il lavoro è completo e Claude itera sull'implementazione finché non passano.", prompt: "scrivi prima i test per {feature}, poi implementalo finché non passano", slots: { feature: "il flusso di reimpostazione della password" } }, "fill-gaps-from-a": { title: "Colmare le lacune da un report di copertura", teaches: "Indica il report di copertura invece di indovinare cosa non è testato. Claude legge i numeri reali e scrive test per i file che ne hanno più bisogno.", next: "Imposta questo come /goal in modo che Claude continui a scrivere test fino a raggiungere l'obiettivo di copertura", prompt: "leggi {report} e aggiungi test per i file con la copertura più bassa finché ciascuno non supera il {target}%", slots: { report: "coverage/coverage-summary.json", target: "80" } }, "port-code-between-languages": { title: "Portare il codice in un altro linguaggio", teaches: "Di' cosa preservare, non solo il linguaggio di destinazione. Indicare l'API o il comportamento che deve restare invariato dà a Claude un contratto rispetto al quale verificare il porting.", prompt: "porta {source} in {target}, mantenendo invariati {keep}", slots: { source: "questo modulo Python", target: "Rust", keep: "l'API pubblica e il comportamento dei test" } }, "generate-docs-for-code": { title: "Generare documentazione per codice non documentato", teaches: "Indica l'ambito e il formato. Claude trova cosa manca e si adegua allo stile dei commenti già presente nel file, così la nuova documentazione è coerente con il resto.", prompt: "trova {scope} senza commenti {format} e aggiungili, rispettando lo stile già usato nel file", slots: { scope: "le funzioni pubbliche in src/auth/", format: "JSDoc" } }, "migrate-a-pattern-across": { title: "Migrare uno schema in tutto il codebase", teaches: "Descrivi il vecchio schema e quello nuovo. Chiedere a Claude di identificare prima ogni punto fa sì che i punti di chiamata siano elencati nella risposta, così puoi verificare che non ne manchi nessuno. Per una migrazione su molti file, esegui /batch. Claude suddivide il lavoro in unità che approvi tu, poi i subagent in background apportano le modifiche.", prompt: "migra tutto da {from} a {to}: identifica ogni punto che deve cambiare, poi apporta le modifiche", slots: { from: "vecchia API di logging", to: "logger strutturato" } }, "optimize-against-a-measurable": { title: "Ottimizzare rispetto a un obiettivo misurabile", teaches: "Indicare la metrica e l'obiettivo dà a Claude una definizione chiara di completamento.", next: "Imposta questo come /goal in modo che Claude continui a misurare e iterare fino a raggiungere il numero", prompt: "ottimizza {target} per portare {metric} da {current} a meno di {goal}", slots: { target: "la query di ricerca", metric: "la latenza p95", current: "2s", goal: "500ms" } }, "fix-a-precise-visual": { title: "Correggere un bug visivo preciso", teaches: "Un feedback visivo preciso porta a una correzione precisa. Indica l'elemento esatto, la misura e il viewport.", next: "Aggiungi uno strumento di anteprima in modo che Claude faccia uno screenshot e verifichi la correzione da solo", prompt: "il {element} sporge di {amount} oltre il {container} su {viewport}. correggilo.", slots: { element: "pulsante di login", amount: "20px", container: "bordo della card", viewport: "mobile" } }, "review-your-changes-before": { title: "Rivedere le tue modifiche prima del commit", teaches: "Individua i problemi quando sono ancora poco costosi da correggere. Claude legge i file modificati per intero, non solo le righe del diff, così individua problemi che una rapida autorevisione non coglie.", next: "Esegui /code-review per lo stesso controllo con un solo comando", prompt: "rivedi le mie modifiche non ancora committate e segnala tutto ciò che sembra rischioso prima che io faccia il commit" }, "review-a-pull-request": { title: "Rivedere una pull request", teaches: "Claude esegue la revisione con l'intero codebase nel contesto, non solo il diff. Legge il codice modificato e ciò che richiama, così individua problemi che una revisione del solo diff non coglierebbe.", next: "Esegui /code-review <pr#> con un solo comando, oppure attiva Code Review per ogni PR", prompt: "rivedi la PR #{pr} e riassumi cosa è cambiato, poi elenca eventuali dubbi", slots: { pr: "247" } }, "review-infrastructure-changes-before": { title: "Rivedere le modifiche all'infrastruttura prima di applicarle", teaches: "L'output del piano è denso e difficile da scorrere. Incollandolo ottieni un riepilogo in linguaggio semplice di cosa cambierà effettivamente prima di applicarlo.", prompt: "ecco l'output del mio piano Terraform. cosa farà, e c'è qualcosa qui che causerà problemi?" }, "run-a-security-review": { title: "Eseguire una revisione di sicurezza con un subagent", teaches: "Un subagent esegue l'audit nella propria finestra di contesto e restituisce un riepilogo, così una lunga revisione di sicurezza non riempie la tua sessione principale. Il subagent generico integrato se ne occupa senza configurazione aggiuntiva.", next: "Configura un subagent dedicato alla revisione di sicurezza che tutto il tuo team può usare", prompt: "usa un subagent per esaminare {path} alla ricerca di problemi di sicurezza e riferisci cosa trova", slots: { path: "src/api/" } }, "review-content-before-sending": { title: "Individuare i problemi prima della revisione formale", teaches: "Ottieni un primo controllo prima che una persona ci dedichi del tempo. Indica gli aspetti che vuoi verificare in modo che la revisione sia mirata, poi correggi ciò che emerge e invia una bozza più pulita.", next: "Salva la tua checklist di revisione come skill che tutto il tuo team può eseguire", prompt: "rivedi {file} per individuare {concerns} ed elenca tutto ciò che dovrei correggere prima di inviarlo a {reviewer}", slots: { file: "launch-post.md", concerns: "affermazioni non supportate, attribuzioni mancanti e problemi con le linee guida del brand", reviewer: "l'ufficio legale" } }, "course-correct-a-wrong": { title: "Correggere la rotta di un approccio sbagliato", teaches: "Indica il vincolo che Claude non ha considerato, non solo che è sbagliato. Una ragione specifica dà a Claude un vincolo concreto da soddisfare al nuovo tentativo, invece di tirare a indovinare di nuovo.", next: "Premi Esc due volte per aprire il menu di rewind e ripristinare codice e conversazione, così il nuovo tentativo parte da zero", prompt: "non va bene: {feedback}. prova un approccio diverso", slots: { feedback: "la firma della funzione deve restare retrocompatibile" } }, "narrow-the-scope-of": { title: "Restringere la portata di una modifica", teaches: "Quando la direzione è giusta ma la modifica è andata troppo oltre, chiedi a Claude di mantenerne una parte invece di annullare tutto. Un limite esplicito impedisce che una piccola correzione diventi un refactoring.", prompt: "è troppo. mantieni solo le modifiche a {scope} e annulla le altre modifiche", slots: { scope: "la logica di validazione in src/forms/" } }, "turn-a-correction-into": { title: "Trasformare una correzione in una regola", teaches: "Una correzione in chat non viene condivisa con il tuo team. Una regola nel CLAUDE.md del progetto viene condivisa una volta che ne fai il commit, e Claude la legge all'inizio di ogni sessione.", next: "Apri /memory per rivedere ciò che Claude ha scritto", prompt: "continui a {mistake}. aggiungi una regola a CLAUDE.md così non succede più", slots: { mistake: "usare export default quando questo progetto usa export con nome" } }, "resolve-merge-conflicts": { title: "Risolvere i conflitti di merge", teaches: "Di' quale stato vuoi ottenere, non quali marcatori mantenere. Chiedere il ragionamento rende il merge verificabile invece di una scatola nera.", prompt: "risolvi i conflitti di merge in questo branch e spiega cosa hai mantenuto da ciascun lato" }, "commit-with-a-generated": { title: "Fare il commit con un messaggio generato", teaches: "Lascia che Claude ricavi il messaggio dal diff. Si adegua allo stile dei commit già presente nel tuo repository.", prompt: "fai il commit di queste modifiche con un messaggio che riassuma cosa ho fatto" }, "open-a-pull-request": { title: "Aprire una pull request da un ticket", teaches: "Evita il cambio di contesto tra tracker, editor e GitHub. Un solo prompt legge la specifica, apporta la modifica e apre la PR.", prompt: "trova il ticket {tracker} relativo a {topic} e apri una PR che lo implementi", slots: { tracker: "Linear", topic: "il timeout del login" } }, "draft-release-notes-from": { title: "Scrivere le note di rilascio dalla cronologia git", teaches: "Fornisci due punti di riferimento e la struttura che vuoi. Claude legge il log dei commit tra i due e scrive una bozza di changelog che puoi modificare.", next: "Salva questo come skill /changelog", prompt: "confronta {from} con {to} e scrivi una bozza delle note di rilascio raggruppate per funzionalità, correzione e breaking change", slots: { from: "v2.3.0", to: "v2.4.0" } }, "write-a-ci-workflow": { title: "Scrivere un workflow CI", teaches: "Descrivi quando deve essere eseguito e cosa deve fare; lo YAML viene generato per te, in linea con i comandi di build e test del tuo progetto.", prompt: "scrivi un workflow GitHub Actions che {steps} a ogni push su {branch}", slots: { steps: "esegua i test e faccia il deploy in staging", branch: "main" } }, "find-and-fix-a": { title: "Trovare e correggere un test che fallisce", teaches: "Descrivi il sintomo; non serve sapere quale file è rotto. Claude esegue il test per vedere l'errore, ne risale l'origine nel sorgente e lo corregge.", prompt: "il test {test} fallisce, scopri perché e correggilo", slots: { test: "UserAuth" } }, "investigate-a-reported-error": { title: "Analizzare un errore segnalato", teaches: "Descrivi il sintomo e dove si verifica; Claude legge il percorso di codice rilevante e individua le cause probabili. Incolla stack trace o log se li hai.", next: "Inserisci nel tuo runbook un deeplink che apre Claude con questo prompt precompilato", prompt: "gli utenti vedono {symptom} su {where}. indaga e dimmi cosa sta succedendo", slots: { symptom: "errori 500", where: "/api/settings" } }, "fix-a-build-error": { title: "Correggere un errore di build alla radice", teaches: "Chiedere la causa principale e la verifica evita patch superficiali che nascondono l'errore senza correggerlo.", prompt: "ecco un errore di build. correggi la causa principale e verifica che la build vada a buon fine" }, "investigate-a-production-incident": { title: "Analizzare un incidente di produzione", teaches: "Elenca le fonti di informazioni da correlare, non i passaggi da seguire. Claude legge insieme log, cronologia git e configurazione per restringere la causa.", next: "Collega Sentry o il tuo log store tramite MCP", prompt: "{symptom}. controlla i log, i deploy recenti e le modifiche alla configurazione, poi dimmi la causa più probabile", slots: { symptom: "l'endpoint di checkout ha iniziato a restituire errori 500 un'ora fa" } }, "query-logs-in-plain": { title: "Interrogare i log in linguaggio naturale", teaches: "Fai la domanda invece di scrivere l'SQL. Claude crea la query, la esegue sui log collegati e mostra sia la query sia il risultato, così puoi verificare cosa è stato eseguito.", prompt: "mostrami tutti i {events} per {scope} durante {timeframe}. scrivi la query, eseguila e dimmi cosa spicca", slots: { events: "login non riusciti", scope: "il servizio di autenticazione", timeframe: "le ultime 24 ore" } }, "diagnose-from-a-console": { title: "Diagnosticare da uno screenshot della console", teaches: "Le console cloud ti mostrano il problema ma non i comandi per risolverlo. Claude legge lo screenshot e traduce la dashboard nei comandi kubectl, gcloud o aws da eseguire.", prompt: "ecco uno screenshot di {console}. spiegami passo passo perché {resource} non funziona e dammi i comandi esatti per risolvere il problema", slots: { console: "la dashboard Kubernetes di GCP", resource: "questo pod" } }, "analyze-a-data-file": { title: "Analizzare un file di dati", teaches: "Una domanda occasionale non richiede uno script occasionale. Indica un file nella cartella del tuo progetto e Claude lo legge direttamente, individua gli schemi e scrive l'output dove chiedi.", next: "Collega la fonte di dati tramite MCP invece di esportare file", prompt: "leggi {file}, riassumi gli schemi principali e scrivi i risultati in {output}", slots: { file: "@reports/q1-signups.csv", output: "una pagina HTML con grafici, poi aprila nel mio browser" } }, "generate-variations-from-performance": { title: "Generare variazioni dai dati di performance", teaches: "Dichiara il vincolo all'inizio, così la generazione resta entro il limite. Claude legge le metriche, sceglie cosa sostituire e produce alternative che rispettano il vincolo.", next: "Collega la piattaforma pubblicitaria tramite MCP invece di esportare un file", prompt: "leggi {file}, trova {items} con le performance peggiori e genera {n} nuove variazioni che restino sotto i {limit} caratteri", slots: { file: "@ads-performance.csv", items: "i titoli", n: "20", limit: "90" } }, "turn-a-recurring-task": { title: "Trasformare un'attività ricorrente in una skill", teaches: "Indica i passaggi una volta sola; riutilizzali come comando. Claude scrive una skill che chiunque nel tuo team può eseguire.", prompt: "crea una skill /{name} per questo progetto che {steps}", slots: { name: "ship", steps: "esegua il linter e i test, poi scriva una bozza del messaggio di commit" } }, "add-a-hook-for": { title: "Aggiungere un hook per un comportamento ricorrente", teaches: "Gli hook rendono un comportamento automatico invece di qualcosa che devi ricordarti di chiedere. Descrivi il trigger e l'azione e Claude scrive la configurazione dell'hook.", prompt: "scrivi un hook che {action} dopo ogni {event}", slots: { action: "esegua prettier", event: "modifica a un file .ts o .tsx" } }, "connect-a-tool-with": { title: "Collegare uno strumento con MCP", teaches: "Collega la fonte una volta sola invece di incollare i dati in ogni sessione. Dopo la configurazione di MCP, Claude legge direttamente dallo strumento quando gli chiedi qualcosa al riguardo.", prompt: "configura il server MCP {server} in modo che tu possa leggere direttamente i miei {data}", slots: { server: "Sentry", data: "report degli errori" } }, "capture-what-to-remember": { title: "Annotare cosa ricordare per la prossima volta", teaches: "Chiedi prima di dimenticare. Claude sa cosa ha dovuto capire in questa sessione e propone voci per CLAUDE.md, così la sessione successiva inizia con quel contesto.", prompt: "riassumi cosa abbiamo fatto in questa sessione e suggerisci cosa aggiungere a CLAUDE.md" } };

Cosa rende questi prompt efficaci

I prompt sopra condividono alcuni modelli. Riconoscerli vi aiuta ad adattare qualsiasi prompt qui al vostro compito.

Descrivete il risultato, non i passaggi. Dite quello che volete e lasciate che Claude trovi i file. Il prompt sottostante funziona senza nominare un singolo percorso di file.

add rate limiting to the public API and make sure existing tests still pass

Dategli un modo per controllare il suo lavoro. Chiedete di eseguire, testare, confrontare o verificare nello stesso prompt in modo che Claude iteri invece di fermarsi dopo un tentativo. Per controllare la modifica completata rispetto all'app in esecuzione, eseguite /verify.

write the migration, run it against the dev database, and confirm the schema matches

Puntate a un riferimento. Nominate un file, test o modello esistente da abbinare in modo che il nuovo codice sia coerente con quello che avete già.

add a settings page that follows the same layout as the profile page

Dichiarate l'obiettivo misurabile. Quando l'obiettivo è performance o copertura, date la metrica e la soglia in modo che il completamento sia inequivocabile.

get the bundle size under 200KB and show me what you removed

Dategli l'artefatto. Incollate errori, log, screenshot e output del piano direttamente nel prompt, o digitate @ per fare riferimento a un file. Claude legge la fonte invece della vostra descrizione di essa.

why is the build failing? @build.log

Dite come volete la risposta. Nominate il formato, la lunghezza o il pubblico in modo che la spiegazione si adatti a come la userete. Per rendere un formato il default per ogni risposta, impostate uno stile di output.

explain how the payment retry logic works as an HTML page with a diagram, then open it in my browser

Per ulteriori informazioni su ogni modello, vedete best practice.

Da dove vengono questi

Questi prompt si basano su modelli da risorse Anthropic pubblicate. Ogni card collega alla sua fonte:

Per video tutorial di questi modelli, vedete il corso gratuito Claude Code in Action su Claude Academy.

I prompt su questa pagina sono punti di partenza. Una volta che uno funziona per il vostro progetto, il passo successivo è renderlo ripetibile: salvatelo come una skill in modo che chiunque nel vostro team possa eseguirlo come un /command, e registrate le convenzioni che Claude ha imparato in CLAUDE.md in modo che ogni sessione inizi con quel contesto invece che Claude lo riapprenda. Per cambiamenti più grandi o più rischiosi, plan mode vi mostra l'elenco dei file prima che qualsiasi modifica accada.

Se state introducendo Claude Code in un team, vedete administration per le impostazioni gestite e la politica, e costs and usage per come questo lavoro è fatturato nel vostro piano.